# Alertmanager alerts ke ponsel: routing severity, pengelompokan, dan resolved yang senyap

> Kirim alert Prometheus Alertmanager ke iPhone dan Android sebagai push notification. Satu push per grup alert, alert critical berbunyi keras, warning biasa, notifikasi resolved senyap. Berisi alertmanager.yml yang sudah diuji, contoh rules, dan kapan opsi payload Alertmanager 0.32 menjadi pilihan yang lebih baik.

*29.10.2026*

<!-- source: https://pocketalert.app/id/blog/prometheus-alertmanager-notifications -->

Prometheus bagus dalam mendeteksi bahwa ada sesuatu yang salah. Menyampaikan kabar itu ke seseorang adalah tugas Alertmanager, dan di banyak setup, kabar tersebut berakhir di folder email atau channel Slack yang tidak dibaca siapa pun pada jam 3 pagi.

Alertmanager tidak punya aplikasi push sendiri, tetapi ia memiliki receiver webhook generik, dan itu sudah cukup untuk mendapatkan alert di ponsel Anda. Panduan ini menyiapkannya dengan routing berdasarkan severity: alert `critical` datang dengan keras, warning datang sebagai notifikasi biasa, dan "resolved" datang dengan senyap. Semua di sini diuji dengan Alertmanager 0.34.2 dan Prometheus 3.15.1 di Docker. Payload-nya ditangkap dan dijalankan melalui kode template milik Pocket Alert sendiri.

## Yang Anda butuhkan

- Alertmanager 0.31 atau lebih baru untuk setup lengkap. Versi lama dibahas di bawah.
- Aplikasi Pocket Alert di [iPhone atau Android](/get-app), dan kunci API dari [API Keys](/account/apikeys).
- Paket berbayar untuk setup tiga webhook, karena paket Gratis hanya menyertakan satu webhook. Versi satu webhook ada di bagian akhir.

## Apa yang dikirim Alertmanager

Alertmanager tidak mengirim satu request per alert. Ia mengumpulkan alert ke dalam grup berdasarkan label di `group_by`, lalu mengirim satu notifikasi per grup: sebuah POST dengan body JSON tetap, `"version": "4"`. Saat dua host mati di bawah `group_by: ['alertname']`, satu request dikirim. Berikut contohnya, sedikit dipangkas:

```json
{
  "receiver": "pocketalert-critical",
  "status": "firing",
  "alerts": [
    {
      "status": "firing",
      "labels": {"alertname": "InstanceDown", "instance": "web-1:9100", "job": "node", "severity": "critical"},
      "annotations": {"summary": "web-1:9100 is down"},
      "startsAt": "2026-10-31T16:17:04.374Z",
      "generatorURL": "http://prometheus.example.com:9090/graph?g0.expr=up%7Bjob%3D%22node%22%7D+%3D%3D+0&g0.tab=1"
    },
    {
      "status": "firing",
      "labels": {"alertname": "InstanceDown", "instance": "web-2:9100", "job": "node", "severity": "critical"},
      "annotations": {"summary": "web-2:9100 is down"}
    }
  ],
  "notification_reason": "first notification",
  "groupLabels": {"alertname": "InstanceDown"},
  "commonLabels": {"alertname": "InstanceDown", "job": "node", "severity": "critical"},
  "commonAnnotations": {},
  "routeLabels": {},
  "externalURL": "http://alertmanager.example.com:9093",
  "version": "4",
  "groupKey": "{}/{severity=\"critical\"}:{alertname=\"InstanceDown\"}",
  "truncatedAlerts": 0
}
```

Ada empat hal dalam bentuk payload ini yang membentuk setup:

- **Satu push per grup.** Alert individual ada di array `alerts`, jadi template pesan harus bisa menangani array.
- **`commonAnnotations` sering kosong.** Isinya hanya anotasi yang sama persis di setiap alert dalam grup. Ringkasan yang menyebut instance berbeda di setiap alert, sehingga tidak pernah muncul di sana.
- **`status` milik grup.** Nilainya `resolved` hanya saat setiap alert dalam grup sudah resolved. Saat satu host pulih dan host lain masih mati, statusnya tetap `firing` dan alert yang pulih tercantum di dalamnya dengan `"status": "resolved"` miliknya sendiri.
- **Tidak ada field `level` di level atas**, padahal di situlah webhook Pocket Alert mencari prioritas. Maka prioritas berasal dari level default webhook, itulah sebabnya panduan ini memakai satu webhook untuk setiap tingkat kekerasan.

## Langkah 1: Buat webhook Pocket Alert

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Webhook</th><th><code>default_level</code></th><th>Menerima</th></tr></thead>
<tbody>
<tr><th>Prometheus critical</th><td><code>2</code> (critical)</td><td>Grup firing dengan <code>severity="critical"</code></td></tr>
<tr><th>Prometheus warning</th><td><code>0</code> (default)</td><td>Semua grup firing lainnya</td></tr>
<tr><th>Prometheus resolved</th><td><code>-1</code> (low)</td><td>Grup di mana setiap alert sudah resolved</td></tr>
</tbody>
</table>
</div>

Tombol hanya bisa diatur lewat API, jadi buat ketiganya dengan satu skrip:

```bash
PA_KEY='your-api-key'

FIRING='%groupLabels.alertname%: %alerts.#(status=="firing")#|#% firing
%alerts.#(status=="firing").annotations.summary%
Firing: %alerts.#(status=="firing")#.labels.instance%'

RESOLVED='Resolved: %groupLabels.alertname% (%commonLabels.severity%)
%alerts.#.labels.instance%'

BUTTONS='[{"type":"view","label":"Alertmanager","value":"%externalURL%"}]'

create_webhook() {
  jq -n --arg name "$1" --argjson level "$2" --arg message "$3" --arg actions "$4" \
    '{name: $name, default_level: $level, message: $message, actions: $actions}' |
  curl -sS https://api.pocketalert.app/v1/webhooks \
    -H "Token: $PA_KEY" \
    -H 'Content-Type: application/json' \
    --data-binary @- |
  jq -r '"\(.name): https://p4a.me/wh/\(.url)"'
}

create_webhook 'Prometheus critical' 2 "$FIRING" "$BUTTONS"
create_webhook 'Prometheus warning' 0 "$FIRING" "$BUTTONS"
create_webhook 'Prometheus resolved' -1 "$RESOLVED" ''
```

Skrip ini mencetak tiga URL penerima. Simpan slug di akhir setiap URL; Anda akan menempelkan slug tersebut ke `alertmanager.yml`.

Placeholder `%...%` adalah [path GJSON](https://info.pocketalert.app/api/webhooks/settings), dan GJSON bisa melakukan query pada array:

- `alerts.#(status=="firing")#|#` menghitung alert dalam grup yang masih firing.
- `alerts.#(status=="firing").annotations.summary` adalah ringkasan dari alert firing pertama.
- `alerts.#(status=="firing")#.labels.instance` mencantumkan instance dari semua alert firing. Hasilnya ditampilkan sebagai array JSON, seperti `["web-1:9100","web-2:9100"]`, karena tidak ada fungsi join string.

Path yang tidak ada akan ditampilkan sebagai string kosong, jadi path yang salah menghasilkan baris kosong, bukan alert yang hilang. Pocket Alert memberi judul setiap push webhook `Webhook <name>`, sehingga judulnya berbunyi "Webhook Prometheus critical" dan nama alert ada di baris pertama pesan. `critical` membutuhkan paket berbayar, yang memang diperlukan setup ini untuk tiga webhook. Notifikasi ini tetap berbunyi melewati sakelar senyap dan Jangan Ganggu di iPhone, dan mengambil alih layar di Android. Gunakan `1` (high) jika Anda tidak ingin alert menembus Jangan Ganggu.

## Langkah 2: alertmanager.yml

Ganti tiga placeholder `*_SLUG` dengan slug Anda:

```yaml
route:
  receiver: pocketalert-warning
  group_by: ['alertname']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 4h
  routes:
    - matchers: ['severity="critical"']
      receiver: pocketalert-critical
      group_wait: 10s
      repeat_interval: 1h
    - matchers: ['severity="info"']
      receiver: blackhole

receivers:
  - name: pocketalert-critical
    webhook_configs:
      - url: 'https://p4a.me/wh/{{ if eq .Status "resolved" }}RESOLVED_SLUG{{ else }}CRITICAL_SLUG{{ end }}'
        send_resolved: true
        max_alerts: 20
  - name: pocketalert-warning
    webhook_configs:
      - url: 'https://p4a.me/wh/{{ if eq .Status "resolved" }}RESOLVED_SLUG{{ else }}WARNING_SLUG{{ end }}'
        send_resolved: true
        max_alerts: 20
  - name: blackhole

inhibit_rules:
  - source_matchers: ['severity="critical"']
    target_matchers: ['severity="warning"']
    equal: ['alertname', 'instance', 'mountpoint']
```

Cara kerja bagian-bagiannya:

- **Routing berdasarkan severity.** `severity="critical"` dikirim ke receiver yang keras, `info` dibuang, dan semua yang lain, termasuk alert tanpa label `severity`, jatuh ke receiver warning.
- **URL menentukan webhook.** Sejak 0.31.0, `url` webhook adalah template. Grup dengan status `resolved` dikirim ke webhook senyap, dan yang lain dikirim ke webhook milik receiver. `send_resolved` sudah `true` secara default untuk webhook; nilainya ditulis eksplisit agar tidak ada yang mematikannya tanpa sadar.
- **`max_alerts: 20`** membatasi berapa banyak alert yang masuk ke satu request. Dalam pengujian, 25 host mati sekaligus. Hasilnya satu push berbunyi "20 firing", dan `truncatedAlerts: 5` pada payload.
- **Inhibition.** Saat `DiskSpaceLow` critical menyala untuk sebuah filesystem, warning untuk `alertname`, `instance` dan `mountpoint` yang sama akan dibisukan. `amtool alert query --inhibited` menampilkannya sebagai `suppressed`.

Periksa konfigurasi dan routing sebelum me-reload:

```bash
amtool check-config alertmanager.yml
amtool config routes test --config.file=alertmanager.yml severity=critical alertname=Test
```

Perintah kedua mencetak `pocketalert-critical`.

Jalankan Alertmanager dengan `--web.external-url` yang diatur ke alamat yang bisa Anda buka dari ponsel. Tanpa itu, `externalURL` hanya berisi hostname. Di Docker, nilainya adalah `http://de48ea5ffc29:9093`, yang membuat tombol tidak berguna.

### Periksa versi Anda terlebih dahulu

`alertmanager --version` harus menunjukkan 0.31 atau lebih baru agar URL berbasis template berfungsi. Versi 0.30.1 menerima config yang sama persis, dan `amtool check-config` melaporkan SUCCESS, tetapi tidak me-render template. Request-nya dikirim ke `/wh/%7B%7B%20if%20eq%20.Status...`, yang tidak cocok dengan webhook mana pun. Di versi lama, berikan setiap receiver URL biasa dari webhook miliknya sendiri. Notifikasi resolved kemudian tiba dengan level webhook tersebut.

## Langkah 3: Rules dengan label severity

Routing di atas hanya berfungsi jika rules Anda mengatur `severity`. Berikut dua contoh (lebih banyak ide tentang apa yang dipantau ada di halaman [server monitoring](/use-cases/server-monitoring)), dengan `DiskSpaceLow` pada dua ambang agar inhibit rule punya sesuatu untuk dikerjakan:

```yaml
groups:
  - name: node
    rules:
      - alert: InstanceDown
        expr: up{job="node"} == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: '{{ $labels.instance }} is down'

      - alert: DiskSpaceLow
        expr: node_filesystem_avail_bytes{fstype!~"tmpfs|overlay"} / node_filesystem_size_bytes * 100 < 15
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: '{{ $labels.instance }} {{ $labels.mountpoint }} has {{ printf "%.0f" $value }}% free'

      - alert: DiskSpaceLow
        expr: node_filesystem_avail_bytes{fstype!~"tmpfs|overlay"} / node_filesystem_size_bytes * 100 < 5
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: '{{ $labels.instance }} {{ $labels.mountpoint }} has {{ printf "%.0f" $value }}% free'
```

`promtool check rules rules.yml` memvalidasi file tersebut. Arahkan Prometheus ke file ini dan ke Alertmanager di `prometheus.yml`:

```yaml
rule_files: [rules.yml]
alerting:
  alertmanagers:
    - static_configs:
        - targets: ['alertmanager:9093']
```

## Uji dengan amtool

Picu alert uji, tunggu `group_wait` (10 detik pada route critical), lalu resolve:

```bash
amtool --alertmanager.url=http://localhost:9093 alert add alertname=PocketAlertTest severity=critical instance=test:9100 \
  --annotation='summary="Test alert from amtool"'

amtool --alertmanager.url=http://localhost:9093 alert add alertname=PocketAlertTest severity=critical instance=test:9100 \
  --annotation='summary="Test alert from amtool"' --end="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
```

Pertahankan tanda kutip ganda di dalam anotasi, atau amtool akan memberi peringatan bahwa ia kembali ke parser lamanya. Push resolved tiba pada tick `group_interval` berikutnya, yang dengan config ini bisa memakan waktu hingga 5 menit.

## Yang sampai ke ponsel Anda

Berikut pesan yang di-render Pocket Alert dari payload asli dalam pengujian, saat Prometheus melihat `web-1` dan `web-2` mati lalu kembali:

```text
Webhook Prometheus critical
InstanceDown: 2 firing
web-1:9100 is down
Firing: ["web-1:9100","web-2:9100"]
```

Saat `web-1` pulih, Alertmanager mengirim pembaruan pada `group_interval` berikutnya. Grup masih firing, jadi dikirim ke webhook critical:

```text
Webhook Prometheus critical
InstanceDown: 1 firing
web-2:9100 is down
Firing: ["web-2:9100"]
```

Saat keduanya sudah kembali, push prioritas rendah tiba:

```text
Webhook Prometheus resolved
Resolved: InstanceDown (critical)
["web-1:9100","web-2:9100"]
```

## Timer: menghindari badai push

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Pengaturan</th><th>Fungsinya</th><th>Di sini</th></tr></thead>
<tbody>
<tr><th><code>group_wait</code></th><td>Berapa lama grup baru menunggu alert tambahan sebelum push pertama</td><td>30s, 10s untuk critical</td></tr>
<tr><th><code>group_interval</code></th><td>Jeda minimum antara push untuk grup yang alert-nya berubah</td><td>5m</td></tr>
<tr><th><code>repeat_interval</code></th><td>Pengingat untuk grup yang masih firing dan tidak berubah</td><td>4h, 1h untuk critical</td></tr>
</tbody>
</table>
</div>

Sebuah grup paling banyak mengirim push sekali per `group_interval`, jadi alert yang naik-turun bisa menghasilkan hingga 12 push per jam pada 5m. Gangguan yang berlangsung seharian menghasilkan 24 pengingat dengan `repeat_interval` 1h. Pengelompokan melakukan sebagian besar pekerjaan: kegagalan switch yang mematikan 40 host adalah satu push, bukan 40. Jangan gunakan `group_by: ['...']`, yang mengelompokkan berdasarkan setiap label dan mengembalikannya menjadi satu push per alert. Paket memiliki [batas pesan harian](https://info.pocketalert.app/features/daily-limits) (Starter 1.000 per hari), dan setiap request ke webhook yang menghasilkan pesan dihitung terhadap batas tersebut.

## Tombol: Alertmanager dan Grafana

Template `BUTTONS` di atas menambahkan tombol "Alertmanager". Anda bisa menambahkan hingga tiga [tombol aksi](/features/action-buttons). Yang ini membuka dasbor Grafana untuk instance firing pertama:

```bash
BUTTONS='[{"type":"view","label":"Alertmanager","value":"%externalURL%"},{"type":"view","label":"Grafana","value":"https://grafana.example.com/d/YOUR_DASHBOARD?var-instance=%alerts.#(status=="firing").labels.instance%"}]'
```

Tanda kutip yang tidak di-escape di dalam placeholder terlihat keliru, tetapi tetap berfungsi: Pocket Alert mengganti placeholder terlebih dahulu dan baru mem-parse JSON setelahnya.

Waspadai nilai kosong. Tombol yang `value`-nya kosong akan dibuang dari push tersebut; tombol lain dan pesannya tetap sampai. `%alerts.0.generatorURL%` (tautan grafik Prometheus) adalah target yang baik untuk alert dari Prometheus, tetapi alert yang dikirim dengan amtool tidak memiliki generator URL, sehingga tiba tanpa tombol itu. Tombol aksi adalah fitur berbayar.

## Alertmanager 0.32+: memanggil API secara langsung

Panduan lama menyebutkan bahwa Alertmanager tidak bisa mengubah body webhook. Itu berubah di 0.32.0, yang menambahkan opsi `payload` pada `webhook_configs`. Dikombinasikan dengan `http_config.http_headers`, yang bisa mengirim header `Token`, Alertmanager dapat melakukan POST langsung ke `https://api.pocketalert.app/v1/messages` dengan judul dan level-nya sendiri.

Ada satu jebakan. Alertmanager mem-parse setiap nilai yang di-render sebagai YAML. Dalam pengujian, payload per-field dengan `message: '{{ range .Alerts }}{{ .Annotations.summary }}...'` mengubah ringkasan `web-1:9100: / has 12% free` menjadi objek `{"web-1:9100": "/ has 12% free"}`. API menolaknya dengan `400`. Alertmanager tidak langsung mencoba ulang untuk `4xx`; ia mengirim body yang rusak itu lagi pada setiap `group_interval`, sehingga alert tidak pernah sampai.

Membangun seluruh body dengan `dict` dan `toJson` menghindari masalah ini:

```yaml
receivers:
  - name: pocketalert-api
    webhook_configs:
      - url: https://api.pocketalert.app/v1/messages
        http_config:
          http_headers:
            Token:
              files: [/etc/alertmanager/pocketalert.key]
        payload: >-
          {{ $msg := "" }}{{ range .Alerts }}{{ $msg = printf "%s%s: %s\n" $msg .Status .Annotations.summary }}{{ end }}
          {{ $level := "default" }}{{ if eq .Status "resolved" }}{{ $level = "low" }}{{ else if eq .CommonLabels.severity "critical" }}{{ $level = "critical" }}{{ end }}
          {{ dict "title" (printf "[%s] %s" (toUpper .Status) .GroupLabels.alertname) "message" $msg "level" $level | toJson }}
```

Dengan ringkasan yang mengandung titik dua dan tanda kutip, payload yang dikirim adalah:

```json
{"level":"critical","message":"firing: web-1:9100: / has 4% free, \"quoted\"\nfiring: web-2:9100 / has 3% free\n","title":"[FIRING] DiskSpaceLow"}
```

Versi resolved tiba dengan `"level":"low"`.

Jadi mana yang sebaiknya Anda pakai? API langsung memberi Anda judul sungguhan dan level untuk setiap notifikasi, semuanya dari satu receiver tanpa webhook. Webhook tidak memerlukan kunci API di Alertmanager sama sekali dan bekerja pada versi apa pun (varian URL biasa). Path yang salah di-render sebagai baris kosong, bukan request yang ditolak, dan setiap request muncul di [riwayat webhook](/features/webhook-history). Dokumentasi Alertmanager sendiri memberi label `payload` "use at your own risk", jadi uji dengan amtool sebelum Anda mengandalkannya.

## Di paket Gratis

Paket Gratis memiliki satu webhook, 50 pesan per hari, tanpa tombol, dan `critical` dikirim sebagai `high`. Buat satu webhook dengan `default_level: 1`, letakkan URL biasanya di satu receiver, dan hapus route severity. Notifikasi resolved kemudian juga tiba di `high`, kecuali Anda mengatur `send_resolved: false`. Di Alertmanager 0.32+, config API langsung di atas lebih cocok untuk Gratis, karena tidak memerlukan webhook dan mengatur level untuk setiap notifikasi.

## Jika tidak ada yang masuk

- **Baca log Alertmanager.** Pengiriman yang gagal mencatat `Notify for alerts failed` beserta kode statusnya. `404` berarti slug salah, atau URL berbasis template pada versi yang lebih lama dari 0.31.
- **Buka riwayat webhook** di Pocket Alert. Jika request ada di sana, masalahnya ada pada template. Jika tidak ada, Alertmanager tidak pernah mengirimnya.
- **Baris kosong** berarti sebuah path tidak cocok dengan payload. Nama field bersifat case-sensitive.
- **`%` tepat sebelum placeholder perlu digandakan.** `%` yang diikuti spasi adalah teks biasa, jadi `CPU over 90% on %groupLabels.alertname%` berfungsi. Tulis `%%` jika `%` menempel pada teks lain, seperti `%commonLabels.usage%%%`.
- **Gunakan [webhook tester](/tools/webhook)** untuk menangkap apa yang sebenarnya dikirim Alertmanager Anda sebelum menulis template.

## FAQ

### Apakah ini berfungsi dengan kube-prometheus-stack?

Ya. Receiver adalah konfigurasi Alertmanager biasa, jadi ia masuk ke config Alertmanager chart seperti receiver lainnya. Periksa versi Alertmanager yang di-deploy chart sebelum menggunakan URL berbasis template atau `payload`. Lihat [Kubernetes alerts](/use-cases/kubernetes-alerts) untuk sisi cluster-nya.

### Saya memakai Grafana alerting, bukan Alertmanager. Apa bedanya?

Grafana mengirim format webhook-nya sendiri. Lihat [panduan Grafana](/blog/how-to-integrate-grafana-into-pocketalert).

[Buat akun gratis](/signup), jalankan skripnya, tempelkan tiga slug ke `alertmanager.yml`, dan `InstanceDown` berikutnya akan sampai ke ponsel Anda.
