Zum Inhalt springenZur Seitennavigation springen: vorherige Seite [Zugriffstaste p]/nächste Seite [Zugriffstaste n]
Bezieht sich auf SUSE Enterprise Storage 6

7 Überwachung und Warnmeldungen Edit source

In SUSE Enterprise Storage 6 stellt DeepSea keinen Überwachungs- und Warnmeldungs-Stack mehr auf dem Salt Master bereit. Die Benutzer müssen die Prometheus-Rolle für Prometheus und Alertmanager sowie die Grafana-Rolle für Grafana definieren. Wenn mehreren Knoten die Prometheus- oder Grafana-Rolle zugewiesen ist, wird eine hochverfügbare Einrichtung bereitgestellt.

  • Prometheus ist das Überwachungs- und Warnmeldungs-Toolkit.

  • Alertmanager verarbeitet die durch den Prometheus-Server gesendeten Warnmeldungen.

  • Grafana ist die Visualisierungs- und Warnmeldungs-Software.

  • prometheus-node_exporter ist der auf allen Salt Minions ausgeführte Dienst.

Die Prometheus-Konfiguration und die scrape-Ziele (Export-Daemons) werden automatisch durch DeepSea eingerichtet. DeepSea stellt außerdem eine Liste standardmäßiger Warnmeldungen bereit, z. B. health error (Zustandsfehler), 10% OSDs down (10 % der OSDs inaktiv) oder pgs inactive (PGs inaktiv).

7.1 Pillar-Variablen Edit source

Der Salt Pillar ist ein Schlüssel-Wert-Speicher, der Informationen und Konfigurationswerte an Minions übergibt. Er ist für alle Minions verfügbar, jeweils mit unterschiedlichem Inhalt. Der Salt Pillar ist mit Standardwerten vorbefüllt und kann mit zwei Verfahren angepasst werden:

  • /srv/pillar/ceph/stack/global.yml: Ändert Pillar-Variablen für alle Knoten.

  • /srv/pillar/ceph/stack/CLUSTER_NAME/minions/HOST: Ändert bestimmte Minion-Konfigurationen.

Die folgenden Pillar-Variablen stehen standardmäßig für alle Knoten zur Verfügung:

  monitoring:
  alertmanager:
    config: salt://path/to/config
    additional_flags: ''
  grafana:
    ssl_cert: False # self-signed certs are created by default
    ssl_key: False # self-signed certs are created by default
  prometheus:
    # pass additional configration to prometheus
    additional_flags: ''
    alert_relabel_config: []
    rule_files: []
    # per exporter config variables
    scrape_interval:
      ceph: 10
      node_exporter: 10
      prometheus: 10
      grafana: 10
    relabel_config:
      alertmanager: []
      ceph: []
      node_exporter: []
      prometheus: []
      grafana: []
    metric_relabel_config:
      ceph: []
      node_exporter: []
      prometheus: []
      grafana: []
    target_partition:
      ceph: '1/1'
      node_exporter: '1/1'
      prometheus: '1/1'
      grafana: '1/1'

7.2 Grafana Edit source

Der gesamte Datenverkehr wird durch Grafana verschlüsselt. Sie können entweder eigene SSL-Zertifikate bereitstellen oder ein eigensigniertes Zertifikat erstellen.

Grafana umfasst die folgenden Variablen:

  • ssl_cert

  • ssl_key

Weitere Informationen zum Bereitstellen eigener SSL-Zertifikate finden Sie in Abschnitt 22.9.1.2, „Von einer CA signierte Zertifikate“, weitere Informationen zum Erstellen eines eigenen Zertifikats in Abschnitt 22.9.1.1, „Selbstsignierte Zertifikate“.

7.3 Prometheus Edit source

Prometheus ist die exportprogrammgestützte Konfiguration, die über den Pillar übergeben werden kann. Diese Gruppen werden Exportprogrammen zugeordnet, die Daten bereitstellen. Das Knotenexportprogramm liegt auf allen Knoten vor, Ceph wird durch die Ceph Manager Nodes exportiert, Prometheus und Grafana entsprechend durch die jeweiligen Prometheus- und Grafana-Knoten.

Prometheus umfasst die folgenden Variablen:

  • scrape_interval: Ändert das Scrape-Intervall, also die Häufigkeit des Scrape-Vorgangs für ein Exportprogramm.

  • target_partition: Partitioniert die Scrape-Ziele, wenn mehrere Prometheus-Instanzen bereitgestellt wurden, wobei einige Instanzen nur einen Scrape-Vorgang für einen Teil der gesamten Exportprogramminstanzen durchführen sollen.

  • relabel_config: Schreibt die Kennzeichnungssätze eines Ziels vor Beginn des Scrape-Vorgangs dynamisch neu. Für eine Scrape-Konfiguration können mehrere Neukennzeichnungsschritte konfiguriert werden.

  • metrics_relabel_config: Wird als letzter Schritt vor der Aufnahme auf Beispiele angewendet.

7.4 Alertmanager Edit source

Alertmanager verarbeitet die durch den Prometheus-Server gesendeten Warnmeldungen. Hiermit werden die Warnmeldungen dedupliziert, gruppiert und an den richtigen Empfänger geleitet. Außerdem werden Warnmeldungen stummgeschaltet. Alertmanager wird über die Befehlszeilenflaggen und eine Konfigurationsdatei konfiguriert, in der die Sperrregeln, das Benachrichtigungs-Routing und die Benachrichtigungsempfänger definiert sind.

7.4.1 Konfigurationsdatei Edit source

Die Alertmanager-Konfiguration ist für jede Bereitstellung anders. DeepSea bietet daher keine entsprechenden Standardeinstellungen. Sie müssen eine eigene alertmanager.yml-Konfigurationsdatei bereitstellen. Die Variable Alertmanager installiert standardmäßig die Konfigurationsdatei /etc/prometheus/alertmanager.yml, die als Beispielkonfiguration dienen kann. Wenn die Alertmanager-Konfiguration stattdessen von DeepSea verwaltet werden soll, ergänzen Sie den Pillar (z. B. die Datei/srv/pillar/ceph/stack/ceph/minions/YOUR_SALT_MASTER_MINION_ID.sls) mit dem folgenden Schlüssel:

Ein Beispiel für die gesamte Alertmanager-Konfigurationsdatei finden Sie in Anhang B, Standardwarnmeldungen für SUSE Enterprise Storage 6.

monitoring:
 alertmanager_config:
   /path/to/your/alertmanager/config.yml

Die Alertmanager-Konfigurationsdatei ist im YAML-Format gespeichert. Hierbei gilt das nachfolgende Schema. Parameter in Klammern sind optional. Bei nicht aufgeführten Parametern wird der Standardwert herangezogen. Das Schema umfasst die folgenden generischen Platzhalter:

DURATION

Dauer gemäß dem regulären Ausdruck [0-9]+(ms|[smhdwy]).

LABELNAME

Zeichenkette gemäß dem regulären Ausdruck [a-zA-Z_][a-zA-Z0-9_]*.

LABELVALUE

Zeichenkette mit Unicode-Zeichen.

FILEPATH

Gültiger Pfad im aktuellen Arbeitsverzeichnis.

BOOLEAN

Boolescher Wert mit den Optionen „true“ oder #false“.

STRING

Normale Zeichenkette.

SECRET

Normale Zeichenkette, die als Geheimnis fungiert, z. B. ein Passwort.

TMPL_STRING

Zeichenkette, die vor der Verwendung per Schablone erweitert wird.

TMPL_SECRET

Geheime Zeichenkette, die vor der Verwendung per Schablone erweitert wird.

Beispiel 7.1: Globale Konfiguration

Die Parameter in der Konfiguration global: gelten auch in allen anderen Konfigurationskontexten. Zudem fungieren sie als Standardwerte für andere Konfigurationsabschnitte.

global:
# the time after which an alert is declared resolved if it has not been updated
[ resolve_timeout: DURATION | default = 5m ]

# The default SMTP From header field.
[ smtp_from: TMPL_STRING ]
# The default SMTP smarthost used for sending emails, including port number.
# Port number usually is 25, or 587 for SMTP over TLS
# (sometimes referred to as STARTTLS).
# Example: smtp.example.org:587
[ smtp_smarthost: STRING ]
# The default host name to identify to the SMTP server.
[ smtp_hello: STRING | default = "localhost" ]
[ smtp_auth_username: STRING ]
# SMTP Auth using LOGIN and PLAIN.
[ smtp_auth_password: SECRET ]
# SMTP Auth using PLAIN.
[ smtp_auth_identity: STRING ]
# SMTP Auth using CRAM-MD5.
[ smtp_auth_secret: SECRET ]
# The default SMTP TLS requirement.
[ smtp_require_tls: BOOL | default = true ]

# The API URL to use for Slack notifications.
[ slack_api_url: STRING ]
[ victorops_api_key: STRING ]
[ victorops_api_url: STRING | default = "https://victorops.example.com/integrations/alert/" ]
[ pagerduty_url: STRING | default = "https://pagerduty.example.com/v2/enqueue" ]
[ opsgenie_api_key: STRING ]
[ opsgenie_api_url: STRING | default = "https://opsgenie.example.com/" ]
[ hipchat_api_url: STRING | default = "https://hipchat.example.com/" ]
[ hipchat_auth_token: SECRET ]
[ wechat_api_url: STRING | default = "https://wechat.example.com/cgi-bin/" ]
[ wechat_api_secret: SECRET ]
[ wechat_api_corp_id: STRING ]

# The default HTTP client configuration
[ http_config: HTTP_CONFIG ]

# Files from which custom notification template definitions are read.
# The last component may use a wildcard matcher, e.g. 'templates/*.tmpl'.
templates:
[ - FILEPATH ... ]

# The root node of the routing tree.
route: ROUTE

# A list of notification receivers.
receivers:
- RECEIVER ...

# A list of inhibition rules.
inhibit_rules:
[ - INHIBIT_RULE ... ]
Beispiel 7.2: ROUTE

Ein ROUTE-Block definiert einen Knoten in einem Routing-Baum. Nicht angegebene Parameter werden aus dem übergeordneten Knoten übernommen. Jede Warnmeldung gelangt über die konfigurierte allgemeine Route, die mit allen Warnmeldungen übereinstimmen muss, in den Routing-Baum. Anschließend durchläuft sie die untergeordneten Knoten. Wenn die Option continue auf „false“ eingestellt ist, endet der Durchlauf nach dem ersten untergeordneten Knoten mit Übereinstimmung. Wird die Option auf einem Knoten mit Übereinstimmung auf „true“ eingestellt, wird die Warnmeldung mit nachfolgenden Knoten auf derselben Ebene abgeglichen. Stimmt die Warnmeldung mit keinem untergeordneten Knoten eines Knotens überein, wird sie gemäß den Konfigurationsparametern des aktuellen Knotens verarbeitet.

[ receiver: STRING ]
[ group_by: '[' LABELNAME, ... ']' ]

# If an alert should continue matching subsequent sibling nodes.
[ continue: BOOLEAN | default = false ]

# A set of equality matchers an alert has to fulfill to match a node.
match:
 [ LABELNAME: LABELVALUE, ... ]

# A set of regex-matchers an alert has to fulfill to match a node.
match_re:
 [ LABELNAME: REGEX, ... ]

# Time to wait before sending a notification for a group of alerts.
[ group_wait: DURATION | default = 30s ]

# Time to wait before sending a notification about new alerts
# added to a group of alerts for which an initial notification has
# already been sent.
[ group_interval: DURATION | default = 5m ]

# Time to wait before re-sending a notification
[ repeat_interval: DURATION | default = 4h ]

# Possible child routes.
routes:
 [ - ROUTE ... ]
Beispiel 7.3: INHIBIT_RULE

Eine Sperrregel schaltet eine Zielwarnmeldung, die mit einer Abgleichreihe übereinstimmt, stumm, wenn eine Quellwarnmeldung vorliegt, die mit einer anderen Abgleichreihe übereinstimmt. Beide Warnmeldungen müssen dieselben Kennzeichnungswerte für die Kennzeichnungsnamen in der Liste equal aufweisen.

Warnmeldungen können mit sich selbst übereinstimmen und sich folglich selbst sperren. Schreiben Sie keine Sperrregeln, in der eine Warnmeldung sowohl mit der Quelle als auch mit dem Ziel übereinstimmt.

# Matchers that need to be fulfilled for the alerts to be muted.
target_match:
 [ LABELNAME: LABELVALUE, ... ]
target_match_re:
 [ LABELNAME: REGEX, ... ]

# Matchers for which at least one alert needs to exist so that the
# inhibition occurs.
source_match:
 [ LABELNAME: LABELVALUE, ... ]
source_match_re:
 [ LABELNAME: REGEX, ... ]

# Labels with an equal value in the source and target
# alert for the inhibition to take effect.
[ equal: '[' LABELNAME, ... ']' ]
Beispiel 7.4: HTTP_CONFIG

Mit HTTP_CONFIG wird der HTTP-Client konfiguriert, über den der Empfänger mit den API-Diensten kommuniziert.

Die Optionen basic_auth, bearer_token und bearer_token_file schließen sich gegenseitig aus.

# Sets the 'Authorization' header with the user name and password.
basic_auth:
[ username: STRING ]
[ password: SECRET ]

# Sets the 'Authorization' header with the bearer token.
[ bearer_token: SECRET ]

# Sets the 'Authorization' header with the bearer token read from a file.
[ bearer_token_file: FILEPATH ]

# TLS settings.
tls_config:
# CA certificate to validate the server certificate with.
[ ca_file: FILEPATH ]
# Certificate and key files for client cert authentication to the server.
[ cert_file: FILEPATH ]
[ key_file: FILEPATH ]
# ServerName extension to indicate the name of the server.
# http://tools.ietf.org/html/rfc4366#section-3.1
[ server_name: STRING ]
# Disable validation of the server certificate.
[ insecure_skip_verify: BOOLEAN | default = false]

# Optional proxy URL.
[ proxy_url: STRING ]
Beispiel 7.5: RECEIVER

„Receiver“ ist eine benannte Konfiguration für eine oder mehrere Benachrichtigungsintegrationen.

Statt neue Empfänger hinzuzufügen, wird empfohlen, benutzerdefinierte Benachrichtigungsintegrationen über den Webhook-Empfänger einzurichten (siehe Beispiel 7.15, „WEBHOOK_CONFIG).

# The unique name of the receiver.
name: STRING

# Configurations for several notification integrations.
email_configs:
[ - EMAIL_CONFIG, ... ]
hipchat_configs:
[ - HIPCHAT_CONFIG, ... ]
pagerduty_configs:
[ - PAGERDUTY_CONFIG, ... ]
pushover_configs:
[ - PUSHOVER_CONFIG, ... ]
slack_configs:
[ - SLACK_CONFIG, ... ]
opsgenie_configs:
[ - OPSGENIE_CONFIG, ... ]
webhook_configs:
[ - WEBHOOK_CONFIG, ... ]
victorops_configs:
[ - VICTOROPS_CONFIG, ... ]
wechat_configs:
[ - WECHAT_CONFIG, ... ]
Beispiel 7.6: EMAIL_CONFIG
# Whether to notify about resolved alerts.
[ send_resolved: BOOLEAN | default = false ]

# The email address to send notifications to.
to: TMPL_STRING

# The sender address.
[ from: TMPL_STRING | default = global.smtp_from ]

# The SMTP host through which emails are sent.
[ smarthost: STRING | default = global.smtp_smarthost ]

# The host name to identify to the SMTP server.
[ hello: STRING | default = global.smtp_hello ]

# SMTP authentication details.
[ auth_username: STRING | default = global.smtp_auth_username ]
[ auth_password: SECRET | default = global.smtp_auth_password ]
[ auth_secret: SECRET | default = global.smtp_auth_secret ]
[ auth_identity: STRING | default = global.smtp_auth_identity ]

# The SMTP TLS requirement.
[ require_tls: BOOL | default = global.smtp_require_tls ]

# The HTML body of the email notification.
[ html: TMPL_STRING | default = '{{ template "email.default.html" . }}' ]
# The text body of the email notification.
[ text: TMPL_STRING ]

# Further headers email header key/value pairs. Overrides any headers
# previously set by the notification implementation.
[ headers: { STRING: TMPL_STRING, ... } ]
Beispiel 7.7: HIPCHAT_CONFIG
# Whether or not to notify about resolved alerts.
[ send_resolved: BOOLEAN | default = false ]

# The HipChat Room ID.
room_id: TMPL_STRING
# The authentication token.
[ auth_token: SECRET | default = global.hipchat_auth_token ]
# The URL to send API requests to.
[ api_url: STRING | default = global.hipchat_api_url ]

# A label to be shown in addition to the sender's name.
[ from:  TMPL_STRING | default = '{{ template "hipchat.default.from" . }}' ]
# The message body.
[ message:  TMPL_STRING | default = '{{ template "hipchat.default.message" . }}' ]
# Whether this message will trigger a user notification.
[ notify:  BOOLEAN | default = false ]
# Determines how the message is treated by the alertmanager and rendered inside HipChat. Valid values are 'text' and 'html'.
[ message_format:  STRING | default = 'text' ]
# Background color for message.
[ color:  TMPL_STRING | default = '{{ if eq .Status "firing" }}red{{ else }}green{{ end }}' ]

# Configuration of the HTTP client.
[ http_config: HTTP_CONFIG | default = global.http_config ]
Beispiel 7.8: PAGERDUTY_CONFIG

Die Optionen routing_key und service_key schließen sich gegenseitig aus.

# Whether or not to notify about resolved alerts.
[ send_resolved: BOOLEAN | default = true ]

# The PagerDuty integration key (when using 'Events API v2').
routing_key: TMPL_SECRET
# The PagerDuty integration key (when using 'Prometheus').
service_key: TMPL_SECRET

# The URL to send API requests to.
[ url: STRING | default = global.pagerduty_url ]

# The client identification of the Alertmanager.
[ client:  TMPL_STRING | default = '{{ template "pagerduty.default.client" . }}' ]
# A backlink to the notification sender.
[ client_url:  TMPL_STRING | default = '{{ template "pagerduty.default.clientURL" . }}' ]

# The incident description.
[ description: TMPL_STRING | default = '{{ template "pagerduty.default.description" .}}' ]

# Severity of the incident.
[ severity: TMPL_STRING | default = 'error' ]

# A set of arbitrary key/value pairs that provide further details.
[ details: { STRING: TMPL_STRING, ... } | default = {
 firing:       '{{ template "pagerduty.default.instances" .Alerts.Firing }}'
 resolved:     '{{ template "pagerduty.default.instances" .Alerts.Resolved }}'
 num_firing:   '{{ .Alerts.Firing | len }}'
 num_resolved: '{{ .Alerts.Resolved | len }}'
} ]

# The HTTP client's configuration.
[ http_config: HTTP_CONFIG | default = global.http_config ]
Beispiel 7.9: PUSHOVER_CONFIG
# Whether or not to notify about resolved alerts.
[ send_resolved: BOOLEAN | default = true ]

# The recipient user key.
user_key: SECRET

# Registered application’s API token.
token: SECRET

# Notification title.
[ title: TMPL_STRING | default = '{{ template "pushover.default.title" . }}' ]

# Notification message.
[ message: TMPL_STRING | default = '{{ template "pushover.default.message" . }}' ]

# A supplementary URL displayed together with the message.
[ url: TMPL_STRING | default = '{{ template "pushover.default.url" . }}' ]

# Priority.
[ priority: TMPL_STRING | default = '{{ if eq .Status "firing" }}2{{ else }}0{{ end }}' ]

# How often the Pushover servers will send the same notification (at least 30 seconds).
[ retry: DURATION | default = 1m ]

# How long your notification will continue to be retried (unless the user
# acknowledges the notification).
[ expire: DURATION | default = 1h ]

# Configuration of the HTTP client.
[ http_config: HTTP_CONFIG | default = global.http_config ]
Beispiel 7.10: SLACK_CONFIG
# Whether or not to notify about resolved alerts.
[ send_resolved: BOOLEAN | default = false ]

# The Slack webhook URL.
[ api_url: SECRET | default = global.slack_api_url ]

# The channel or user to send notifications to.
channel: TMPL_STRING

# API request data as defined by the Slack webhook API.
[ icon_emoji: TMPL_STRING ]
[ icon_url: TMPL_STRING ]
[ link_names: BOOLEAN | default = false ]
[ username: TMPL_STRING | default = '{{ template "slack.default.username" . }}' ]
# The following parameters define the attachment.
actions:
[ ACTION_CONFIG ... ]
[ color: TMPL_STRING | default = '{{ if eq .Status "firing" }}danger{{ else }}good{{ end }}' ]
[ fallback: TMPL_STRING | default = '{{ template "slack.default.fallback" . }}' ]
fields:
[ FIELD_CONFIG ... ]
[ footer: TMPL_STRING | default = '{{ template "slack.default.footer" . }}' ]
[ pretext: TMPL_STRING | default = '{{ template "slack.default.pretext" . }}' ]
[ short_fields: BOOLEAN | default = false ]
[ text: TMPL_STRING | default = '{{ template "slack.default.text" . }}' ]
[ title: TMPL_STRING | default = '{{ template "slack.default.title" . }}' ]
[ title_link: TMPL_STRING | default = '{{ template "slack.default.titlelink" . }}' ]
[ image_url: TMPL_STRING ]
[ thumb_url: TMPL_STRING ]

# Configuration of the HTTP client.
[ http_config: HTTP_CONFIG | default = global.http_config ]
Beispiel 7.11: ACTION_CONFIG für SLACK_CONFIG
# Provide a button to tell Slack you want to render a button.
type: TMPL_STRING
# Label for the button.
text: TMPL_STRING
# http or https URL to deliver users to. If you specify invalid URLs, the message will be posted with no button.
url: TMPL_STRING
#  If set to 'primary', the button will be green, indicating the best forward action to take
#  'danger' turns the button red, indicating a destructive action.
[ style: TMPL_STRING [ default = '' ]
Beispiel 7.12: FIELD_CONFIG für SLACK_CONFIG
# A bold heading without markup above the value text.
title: TMPL_STRING
# The text of the field. It can span across several lines.
value: TMPL_STRING
# A flag indicating if value is short enough to be displayed together with other values.
[ short: BOOLEAN | default = slack_config.short_fields ]
Beispiel 7.13: OPSGENIE_CONFIG
# Whether or not to notify about resolved alerts.
[ send_resolved: BOOLEAN | default = true ]

# The API key to use with the OpsGenie API.
[ api_key: SECRET | default = global.opsgenie_api_key ]

# The host to send OpsGenie API requests to.
[ api_url: STRING | default = global.opsgenie_api_url ]

# Alert text (maximum is 130 characters).
[ message: TMPL_STRING ]

# A description of the incident.
[ description: TMPL_STRING | default = '{{ template "opsgenie.default.description" . }}' ]

# A backlink to the sender.
[ source: TMPL_STRING | default = '{{ template "opsgenie.default.source" . }}' ]

# A set of arbitrary key/value pairs that provide further detail.
[ details: { STRING: TMPL_STRING, ... } ]

# Comma separated list of team responsible for notifications.
[ teams: TMPL_STRING ]

# Comma separated list of tags attached to the notifications.
[ tags: TMPL_STRING ]

# Additional alert note.
[ note: TMPL_STRING ]

# Priority level of alert, one of P1, P2, P3, P4, and P5.
[ priority: TMPL_STRING ]

# Configuration of the HTTP.
[ http_config: HTTP_CONFIG | default = global.http_config ]
Beispiel 7.14: VICTOROPS_CONFIG
# Whether or not to notify about resolved alerts.
[ send_resolved: BOOLEAN | default = true ]

# The API key for talking to the VictorOps API.
[ api_key: SECRET | default = global.victorops_api_key ]

# The VictorOps API URL.
[ api_url: STRING | default = global.victorops_api_url ]

# A key used to map the alert to a team.
routing_key: TMPL_STRING

# Describes the behavior of the alert (one of 'CRITICAL', 'WARNING', 'INFO').
[ message_type: TMPL_STRING | default = 'CRITICAL' ]

# Summary of the alerted problem.
[ entity_display_name: TMPL_STRING | default = '{{ template "victorops.default.entity_display_name" . }}' ]

# Long explanation of the alerted problem.
[ state_message: TMPL_STRING | default = '{{ template "victorops.default.state_message" . }}' ]

# The monitoring tool the state message is from.
[ monitoring_tool: TMPL_STRING | default = '{{ template "victorops.default.monitoring_tool" . }}' ]

# Configuration of the HTTP client.
[ http_config: HTTP_CONFIG | default = global.http_config ]
Beispiel 7.15: WEBHOOK_CONFIG

Mit dem Webhook-Empfänger können Sie einen generischen Empfänger konfigurieren.

# Whether or not to notify about resolved alerts.
[ send_resolved: BOOLEAN | default = true ]

# The endpoint for sending HTTP POST requests.
url: STRING

# Configuration of the HTTP client.
[ http_config: HTTP_CONFIG | default = global.http_config ]

Alertmanager sendet HTTP-POST-Anfragen im folgenden JSON-Format:

{
 "version": "4",
 "groupKey": STRING, // identifycation of the group of alerts (to deduplicate)
 "status": "<resolved|firing>",
 "receiver": STRING,
 "groupLabels": OBJECT,
 "commonLabels": OBJECT,
 "commonAnnotations": OBJECT,
 "externalURL": STRING, // backlink to Alertmanager.
 "alerts": [
   {
     "status": "<resolved|firing>",
     "labels": OBJECT,
     "annotations": OBJECT,
     "startsAt": "<rfc3339>",
     "endsAt": "<rfc3339>",
     "generatorURL": STRING // identifies the entity that caused the alert
   },
   ...
 ]
}

Der Webhook-Empfänger ermöglicht die Integration in die folgenden Benachrichtigungsmechanismen:

  • DingTalk (https://github.com/timonwong/prometheus-webhook-dingtalk)

  • IRC-Bot (https://github.com/multimfi/bot)

  • JIRAlert (https://github.com/free/jiralert)

  • Phabricator/Maniphest (https://github.com/knyar/phalerts)

  • prom2teams: leitet Benachrichtigungen an Microsoft-Teams weiter (https://github.com/idealista/prom2teams)

  • SMS: unterstützt mehrere Anbieter (https://github.com/messagebird/sachet)

  • Telegram-Bot (https://github.com/inCaller/prometheus_bot)

  • SNMP-Trap (https://github.com/SUSE/prometheus-webhook-snmp)

Beispiel 7.16: WECHAT_CONFIG
# Whether or not to notify about resolved alerts.
[ send_resolved: BOOLEAN | default = false ]

# The API key to use for the WeChat API.
[ api_secret: SECRET | default = global.wechat_api_secret ]

# The WeChat API URL.
[ api_url: STRING | default = global.wechat_api_url ]

# The corp id used to authenticate.
[ corp_id: STRING | default = global.wechat_api_corp_id ]

# API request data as defined by the WeChat API.
[ message: TMPL_STRING | default = '{{ template "wechat.default.message" . }}' ]
[ agent_id: STRING | default = '{{ template "wechat.default.agent_id" . }}' ]
[ to_user: STRING | default = '{{ template "wechat.default.to_user" . }}' ]
[ to_party: STRING | default = '{{ template "wechat.default.to_party" . }}' ]
[ to_tag: STRING | default = '{{ template "wechat.default.to_tag" . }}' ]

7.4.2 Benutzerdefinierte Warnmeldungen Edit source

Sie können benutzerdefinierte Warnmeldungen definieren und damit Benachrichtigungen an einen externen Dienst senden. In Prometheus werden benutzerdefinierte Warnmeldungen mit der softwareeigenen Ausdruckssprache definiert. Beispiel für eine Regel mit einer Warnmeldung:

groups:
- name: example
 rules:
  # alert on high deviation from average PG count
  - alert: high pg count deviation
   expr: abs(((ceph_osd_pgs > 0) - on (job) group_left avg(ceph_osd_pgs > 0) by (job)) / on (job) group_left avg(ceph_osd_pgs > 0) by (job)) > 0.35
   for: 5m
   labels:
    severity: warning
    type: ses_default
   annotations:
   description: >
    OSD {{ $labels.osd }} deviates by more then 30% from average PG count

Die optionale for-Anweisung gibt an, wie lang Prometheus zwischen dem Auftreten eines neuen Ausdrucksausgabe-Vektorelements und dem Auslösen einer Warnmeldung abwartet. In diesem Fall prüft Prometheus, ob die Warnmeldung 5 Minuten lang aktiv bleibt, bevor die Warnmeldung ausgelöst wird. Elemente mit dem Status „ausstehend“ sind aktiv, werden jedoch noch nicht ausgelöst.

Mit der labels-Anweisung wird eine Reihe zusätzlicher Kennzeichnungen angegeben, die mit der Warnmeldung verbunden sind. Widersprüchliche Kennzeichnungen werden überschrieben. Für die Kennzeichnungen können Schablonen angelegt werden (weitere Informationen zu Schablonen siehe Abschnitt 7.4.2.1, „Vorlagen“).

Mit der annotations-Anweisung werden Informationskennzeichnungen angegeben. Hiermit können Sie zusätzliche Informationen speichern, z. B. Beschreibungen der Warnmeldungen oder Runbook-Links. Für die Anmerkungen können Schablonen angelegt werden (weitere Informationen zu Schablonen siehe Abschnitt 7.4.2.1, „Vorlagen“).

So fügen Sie die benutzerdefinierten Warnmeldungen in SUSE Enterprise Storage 6 ein:

  • Speichern Sie die YAML-Dateien mit den benutzerdefinierten Warnmeldungen im Verzeichnis /etc/prometheus/alerts

oder

  • geben Sie im Pillar unter dem Schlüssel monitoring:custom_alerts eine Liste der Pfade zu den benutzerdefinierten Warnmeldungsdateien an. Mit der DeepSea-Phase 2 oder dem Kommando salt SALT_MASTER state.apply ceph.monitoring.prometheus werden die Warnmeldungsdateien an der richtigen Stelle eingefügt.

    Beispiel 7.17: Einfügen benutzerdefinierter Warnmeldungen in SUSE Enterprise Storage

    Eine Datei mit benutzerdefinierten Warnmeldungen befindet sich in /root/my_alerts/my_alerts.yml auf dem Salt Master. Wenn Sie

    monitoring:
     custom_alerts:
       - /root/my_alerts/my_alerts.yml

    in die Datei /srv/pillar/ceph/cluster/YOUR_SALT_MASTER_MINION_ID.sls einfügen, erstellt DeepSea die Datei /etc/prometheus/alerts/my_alerts.yml und startet Prometheus neu.

7.4.2.1 Vorlagen Edit source

Sie können Schablonen für Kennzeichnungs- und Anmerkungswerte heranziehen. Die Variable $Etiketten umfasst die Schlüssel-Wert-Paare für die Kennzeichnungen einer Warnmeldungsinstanz, $value enthält dagegen den ausgewerteten Wert einer Warnmeldungsinstanz.

Mit dem folgenden Beispiel werden eine Kennzeichnung und ein Wert für ein Auslösungselement eingefügt:

{{ $labels.LABELNAME }}
{{ $value }}

7.4.2.2 Prüfen von Warnmeldungen zur Laufzeit Edit source

Soll festgestellt werden, welche Warnmeldungen aktiv sind, stehen mehrere Optionen zur Auswahl:

  • Navigieren Sie zur Registerkarte Alerts in Prometheus. Hier werden die genauen Kennzeichnungssätze angezeigt, für die die definierten Warnmeldungen aktiviert sind. Prometheus speichert außerdem eine synthetische Zeitfolge für ausstehende und ausgelöste Warnmeldungen. Sie weisen folgende Form auf:

    ALERTS{alertname="ALERT_NAME", alertstate="pending|firing", ADDITIONAL_ALERT_LABELS}

    Der Beispielwert lautet 1, wenn die Warnmeldung aktiv ist (ausstehend oder ausgelöst). Ist die Warnmeldung inaktiv, wird die Reihe als „stale“ gekennzeichnet.

  • In der Prometheus-Weboberfläche unter der URL-Adresse http://PROMETHEUS_HOST_IP:9090/alerts können Sie die Warnmeldungen und ihren Status (INACTIVE, PENDING oder FIRING) prüfen.

  • In er Alertmanager-Weboberfläche unter der URL-Adresse http://:PROMETHEUS_HOST_IP9093/#/alerts können Sie Warnmeldungen prüfen und bei Bedarf stummschalten.

7.4.3 SNMP-Trap-Empfänger Edit source

Wenn Sie mithilfe von SNMP-Traps über Prometheus-Warnmeldungen benachrichtigt werden möchten, können Sie den Prometheus-Alertmanager-SNMP-Trap-Empfänger über DeepSea installieren. Aktivieren Sie ihn hierzu im Pillar unter dem Schlüssel monitoring:alertmanager_receiver_snmp:enabled. Die Konfiguration des Empfängers muss unter dem Schlüssel monitoring:alertmanager_receiver_snmp:config festgelegt werden. Mit der DeepSea-Phase 2 oder dem Kommando salt SALT_MASTER state.apply ceph.monitoring.alertmanager wird der Empfänger am richtigen Speicherort installiert und konfiguriert.

Beispiel 7.18: SNMP-Trap-Konfiguration
monitoring:
 alertmanager:
   receiver:
      snmp:
        enabled: True
        config:
          host: localhost
          port: 9099
          snmp_host: snmp.foo-bar.com
          snmp_community: private
          metrics: True

Im Empfängerhandbuch unter https://github.com/SUSE/prometheus-webhook-snmp#global-configuration-file finden Sie weitere Informationen zu den Konfigurationsoptionen.

Diese Seite drucken