Schritt-für-Schritt-Anleitung zum Einrichten des Prometheus Alertmanager für Slack, PagerDuty, und Gmail

In meinem vorherigen Blogbeitrag, “How to explore Prometheus with easy ‘Hello World’ projects” habe ich drei Projekte beschrieben, mit denen ich ein besseres Verständnis dafür bekam, was Prometheus eigentlich alles kann. In diesem Beitrag zeige ich euch, wie ich mich mit dem Prometheus Alertmanager vertraut gemacht habe und wie ich Benachrichtigungen für Slack, PagerDuty, und Gmail eingerichtet habe.

(Ich beziehe mich öfters auf meinen vorherigen Blogbeitrag, also empfehle ich euch, diesen durchzulesen, bevor ihr hier weiterlest.)

Grundlegendes

Mit Grafana Cloud könnt ihr schon nach wenigen Minuten mit Prometheus loslegen. Wir haben neue, kostenlose und kostenpflichtige Grafana-Cloud-Pläne für jeden Anwendungsbereich – meldet euch jetzt kostenlos an.

Für das Einrichten von Alarms mit Prometheus sind zwei Schritte notwendig:

Zunächst müsst ihr Alarmregeln in Prometheus erstellen und festlegen, bei welchen Bedingungen ihr benachrichtigt werden wollt (wenn zum Beispiel eine Instanz ausfällt).

Danach müsst ihr den Alertmanager einrichten, der die in Prometheus festgelegten Alarms erhält. Der Alertmanager kann dann verschiedenste Dinge tun, unter anderem Folgendes:

• Er kann ähnliche Alarms in einer Benachrichtigung zusammenfassen.
• Er kann Alarms eine bestimmte Zeit lang stumm schalten.
• Er kann Benachrichtigungen für bestimmte Alarms stummschalten, wenn andere bestimmte Alarms bereits ausgelöst wurden.
• Er kann auswählen, welche Empfänger eine bestimmte Alarm erhalten.

Schritt 1: Alarmregeln in Prometheus erstellen

Wir beginnen mit vier Unterordnern, die wir zuvor für jedes Projekt erstellt haben: server, node_exporter, github_exporter, and prom_middleware. Diesen Vorgang erkläre ich in diesem Blogbeitrag an einfachen Projekten in Prometheus.

Wir gehen zum Unterordner server, öffnen den Inhalt im Code-Editor und erstellen eine neue Regeldatei. In der Datei rules.yml gebt ihr die Bedingungen an, zu denen ihr alamiert werden möchtet.

cd Prometheus/server
touch rules.yml

Ihr stimmt mir sicher zu, wenn ich sage, dass es äußerst wichtig ist zu wissen, wenn eine Instanz ausfällt. Daher setze ich das als Bedingung, indem ich die Metrik up verwende. Wird diese Metrik in der Prometheus-Benutzeroberfläche evaluiert (http://localhost:9090), sieht man, dass alle laufenden Instanzen den Wert 1 haben, während alle derzeit nicht laufenden Instanzen den Wert 0 haben (derzeit läuft nur unsere Prometheus-Instanz).

Evaluierung der Metrik „Up” in der Prometheus-Benutzeroberfläche, um zu sehen, welche Instanzen laufen

Nachdem ihr euch für die Bedingungen, zu denen ihr gewarnt werden möchtet, entschieden habt, müssen diese in rules.yml festgelegt werden. Der Inhalt muss folgendermaßen aussehen:

Copy

groups:
- name: AllInstances
  rules:
  - alert: InstanceDown
    # Condition for alerting
    expr: up == 0
    for: 1m
    # Annotation - additional informational labels to store more information
    annotations:
      title: 'Instance {{ $labels.instance }} down'
      description: '{{ $labels.instance }} of job {{ $labels.job }} has been down for more than 1 minute.'
    # Labels - additional labels to be attached to the alert
    labels:
      severity: 'critical'

Zusammenfassend heißt das, dass eine Alarm ausgelöst wird, wenn eine der Instanzen für eine Minute ausfällt (up == 0). Ich habe auch Anmerkungen und Labels hinzugefügt, in denen zusätzliche Informationen zur Alarm angegeben werden können. Für diese können Variablenvorlagen wie {{ $labels.instance }} verwendet werden, die dann in spezifische Instanzen interpoliert werden (wie localhost:9100).

(Weitere Infos zu Alarmregeln in Prometheus findet ihr hier.)

Sobald rules.yml entsprechend angepasst wurde, müsst ihr die Datei mit prometheus.yml verknüpfen und eine Warnkonfiguration hinzufügen. Euer prometheus.yml sollte folgendermaßen aussehen:

Copy

global:
  # How frequently to scrape targets
  scrape_interval:     10s
  # How frequently to evaluate rules
  evaluation_interval: 10s

# Rules and alerts are read from the specified file(s)
rule_files:
  - rules.yml

# Alerting specifies settings related to the Alertmanager
alerting:
  alertmanagers:
    - static_configs:
      - targets:
        # Alertmanager's default port is 9093
        - localhost:9093

# A list of scrape configurations that specifies a set of
# targets and parameters describing how to scrape them.
scrape_configs:
  - job_name: 'prometheus'
    scrape_interval: 5s
    static_configs:
      - targets:
        - localhost:9090
  - job_name: 'node_exporter'
    scrape_interval: 5s
    static_configs:
      - targets:
        - localhost:9100

Wenn ihr Prometheus mit der Flagge --web.enable-lifecycle gestartet habt, könnt ihr die Konfiguration neu laden, indem eine POST-Anfrage an den /-/reload-Endpunkt curl -X POST http://localhost:9090/-/reload geschickt wird. Startet danach die Anwendung prom_middleware (node index.js im Ordner prom_middleware) und node_exporter (./node_exporter im Ordner node_exporter). Sobald dies geschehen ist, könnt ihr jedes Mal, wenn ihr eine Alarm erstellen möchtet, einfach die Anwendung node_exporter oder prom_middleware stoppen.

Schritt 2: Alertmanager einrichten

Erstellt den Unterordner alert_manager im Prometheus-Ordner mkdir alert_manager. Ladet dann in diesen Ordner den Alertmanager von der Website von Prometheus herunter, extrahiert ihn, nehmt keine Änderungen an alertmanager.yml vor, führt `./alertmanager –config.file=alertmanager.yml` aus und öffnet localhost:9093.

Abhängig davon, ob aktive Alarms vorliegen oder nicht, sollte der Alertmanager richtig eingerichtet sein und in etwa wie der folgende Screenshot aussehen. Um die Annotationen anzuzeigen, die im vorherigen Schritt hinzugefügt wurden, klickt man auf die Schaltfläche +Info.

Wenn all dies abgeschlossen ist, sehen wir uns nun die verschiedenen Möglichkeiten an, den Alertmanager zu nutzen und Benachrichtigungen zu Alarm zu versenden.

So werden Slack-Alarms eingerichtet

Wenn ihr Benachrichtigungen über Slack erhalten möchtet, müsst ihr Teil eines Workspaces auf Slack sein. Wenn ihr derzeit nicht Teil eines Slack-Workspaces seid oder die Funktion in einem anderen Workspace ausprobieren möchtet, könnt ihr hier schnell einen erstellen.

Um Alarms in eurem Workspace in Slack einzurichten, braucht ihr eine Slack-API-URL. Geht dazu zu Slack -> Administration -> Apps verwalten.

Sucht im Verzeichnis nach Incoming WebHooks und fügt es zu eurem Slack-Workspace hinzu.

Gebt anschließend an, in welchem Kanal ihr Benachrichtigungen vom Alertmanager erhalten möchtet. (Ich habe dazu den Kanal #monitoring-infrastructre erstellt.) Wenn ihr die Incoming-WebHooks-Intergration bestätigt und hinzugefügt habt, wird eine Webhook-URL (dies ist eure Slack-API-URL) angezeigt. Kopiert sie.

Danach müsst ihr die Datei alertmanager.yml anpassen. Öffnet zunächst den Unterordner alert_manager in eurem Code-Editor und füllt die Datei alertmanager.yml anhand der unten stehenden Vorlage aus. Gebt die URL, die ihr gerade kopiert habt, als slack_api_url an.

Copy

global:
resolve_timeout: 1m
slack_api_url: 'https://hooks.slack.com/services/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'

route:
receiver: 'slack-notifications'

receivers:
- name: 'slack-notifications'
slack_configs:
- channel: '#monitoring-instances'
send_resolved: true

Ladet die Konfiguration neu, indem ihr eine POST-Anfrage an den /-/reload -Endpunkt curl -X POST http://localhost:9093/-/reload sendet. In ein paar Minuten (sobald mindestens eine eurer Instanzen gestoppt wird), solltet ihr eine Warnmeldung über Slack bekommen, die etwa folgendermaßen aussieht:

Wenn ihr eure Benachrichtigungen verbessern und sie etwas hübscher aussehen lassen wollt, könnt ihr die folgende Vorlage nutzen oder dieses Tool ausprobieren und eigene Vorlagen erstellen.

Copy

global:
resolve_timeout: 1m
slack_api_url: 'https://hooks.slack.com/services/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'

route:
receiver: 'slack-notifications'

receivers:
- name: 'slack-notifications'
slack_configs:
- channel: '#monitoring-instances'
send_resolved: true
icon_url: https://avatars3.githubusercontent.com/u/3380462
title: |-
     [{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname }} for {{ .CommonLabels.job }}
{{- if gt (len .CommonLabels) (len .GroupLabels) -}}
       {{" "}}(
{{- with .CommonLabels.Remove .GroupLabels.Names }}
{{- range $index, $label := .SortedPairs -}}
           {{ if $index }}, {{ end }}
{{- $label.Name }}="{{ $label.Value -}}"
         {{- end }}
       {{- end -}}
       )
     {{- end }}
text: >-
{{ range .Alerts -}}
*Alert:* {{ .Annotations.title }}{{ if .Labels.severity }} - `{{ .Labels.severity }}`{{ end }}

*Description:* {{ .Annotations.description }}

*Details:*
{{ range .Labels.SortedPairs }} • *{{ .Name }}:* `{{ .Value }}`
       {{ end }}
     {{ end }}

So sieht das Endergebnis aus:

So richtet ihr PagerDuty-Alarms ein

PagerDuty ist eine der bekanntesten Incident-Response-Platform für IT-Abteilungen. Um Alarms über PagerDuty einzurichten, müsst ihr zunächst ein Konto auf der Plattform erstellen. (PagerDuty ist kostenpflichtig, aber ihr könnt zumindest die 14-tägige Testversion nutzen.) Sobald ihr angemeldet seid, geht zu Konfiguration -> Services -> +Neuer Service.

Wählt Prometheus aus der Liste der Integrationen aus und vergebt einen Namen für den Service. Ich habe meinen Prometheus Alertmanager genannt. (Ihr könnt auch die Incident-Einstellungen anpassen, ich habe mich jedoch hier für die Standardeinrichtung entschieden.) Klickt dann auf „Speichern“

Der Integrationsschlüssel wird angezeigt. Kopiert ihn.

Ihr müsst dann den Inhalt von alertmanager.yml anpassen. Es sollte wie das folgende Beispiel aussehen, jedoch mit eurem eigenen service_key (d. h. eurem Integrationsschlüssel aus PagerDuty). Pagerduty_url sollte gleich bleiben und auf https://events.pagerduty.com/v2/enqueue gesetzt werden. Speichert die Datei und startet den Alertmanager neu.

Copy

global:
resolve_timeout: 1m
pagerduty_url: 'https://events.pagerduty.com/v2/enqueue'

route:
receiver: 'pagerduty-notifications'

receivers:
- name: 'pagerduty-notifications'
pagerduty_configs:
- service_key: 0c1cc665a594419b6d215e81f4e38f7
send_resolved: true

Stoppt eine eurer Instanzen. Nach einigen Minuten sollte eine Warnmeldung in PagerDuty angezeigt werden.

In den PagerDuty-Benutzereinstellungen könnt ihr entscheiden, wie ihr benachrichtigt werden möchtet, also per E-Mail und/oder Telefonanruf. Ich habe mich für beides entschieden, und beide Optionen funktionieren.

So richtet ihr Gmail-Alarms ein

Wenn ihr eure Benachrichtigungen lieber direkt per E-Mail bekommt, ist die Einrichtung noch einfacher. Alertmanager kann Nachrichten einfach an euren Provider – in diesem Fall Gmail – weiterleiten, der dann in eurem Namen entsprechende Nachrichten schickt.

Es wird nicht empfohlen, dafür dein persönliches Passwort zu verwenden. Ihr solltet daher ein App-Passwort erstellen. Geht dazu zu Kontoeinstellungen -> Sicherheit -> Bei Google anmelden -> App-Passwort (wenn die Option „App-Passwort“ nicht angezeigt wird, habt ihr vermutlich die 2-Faktor-Authentifizierung noch nicht eingerichtet. Dann müsst ihr diese zuerst einrichten). Kopiert das neu erstellte Passwort.

Ihr müsst den Inhalt der Datei alertmanager.yml erneut aktualisieren. Der Inhalt sollte wie auf dem folgenden Beispiel aussehen. Vergesst nicht, die E-Mail-Adresse mit eurer eigenen E-Mail-Adresse und das Passwort mit eurem neuen App-Passwort zu ersetzen.

Copy

global:
resolve_timeout: 1m

route:
receiver: 'gmail-notifications'

receivers:
- name: 'gmail-notifications'
email_configs:
- to: monitoringinstances@gmail.com
from: monitoringinstances@gmail.com
smarthost: smtp.gmail.com:587
auth_username: monitoringinstances@gmail.com
auth_identity: monitoringinstances@gmail.com
auth_password: password
send_resolved: true

Auch hier solltet ihr nach ein paar Minuten (nachdem mindestens eine eurer Instanzen gestoppt wurde) eine Warnmeldung auf eure Gmail-Adresse bekommen.

Und das ist auch schon alles!