0x0i.prometheus

Überblick Versionen Einblicke

ansible logo

prometheus logo

Ansible-Rolle :fire: :straight_ruler: Prometheus

Galaxy Role GitHub release (latest by date) License: MIT

Inhalt

Ansible-Rolle, die Prometheus installiert und konfiguriert: eine multidimensionale, nicht-verteilte Zeitreihendatenbank und Überwachungs-/Alarmierungs-Toolkit.

Unterstützte Plattformen:
* Debian
* Redhat(CentOS/Fedora)
* Ubuntu

Anforderungen

Benötigt das Dienstprogramm unzip/gtar, das auf dem Zielhost installiert sein muss. Siehe die Anmerkungen zum Ansible unarchive-Modul hier für Details.

Rollenvariablen

Variablen sind verfügbar und organisiert nach den folgenden Phasen der Software- und Maschinenbereitstellung:

  • installation
  • konfiguration
  • start
  • deinstallation

Installation

prometheus und die zugehörige alertmanager-Software können mit komprimierten Archiven (.tar, .zip) installiert werden, die aus verschiedenen Quellen heruntergeladen und extrahiert werden.

Die folgenden Variablen können angepasst werden, um verschiedene Aspekte dieses Installationsprozesses zu steuern, von der Softwareversion und dem Speicherort der Binaries bis zum Installationsverzeichnis, in dem sie gespeichert werden:

managed_services: <Liste der Dienste (prometheus | alertmanager)> (Standard: ['prometheus'])

  • Liste der Prometheus-Toolkit-Dienste, die über diese Rolle verwaltet werden sollen.

prometheus_user: <Service-Benutzername> (Standard: prometheus)

  • Dedizierter Dienstbenutzer und Gruppe, die von prometheus für die Privilegtrennung verwendet werden (siehe hier für Details).

install_dir: </path/to/installation/dir> (Standard: /opt/prometheus)

  • Pfad auf dem Zielhost, wohin die prometheus-Binaries extrahiert werden sollen.

archive_url: <Pfad oder URL zu Archiv> (Standard: siehe defaults/main.yml)

  • Adresse eines komprimierten tar oder zip-Archivs, das die prometheus-Binaries enthält. Diese Methode unterstützt technisch die Installation jeder verfügbaren Version von prometheus. Links zu den offiziellen Versionen finden Sie hier.

archive_checksum: <Pfad oder URL zur Prüfziffer> (Standard: siehe defaults/main.yml)

  • Adresse einer Prüfziffer-Datei zur Überprüfung der Datenintegrität des angegebenen prometheus-Archivs. Obwohl empfohlen und allgemein als bewährte Praxis angesehen, ist es nicht erforderlich, eine Prüfziffer anzugeben, und kann deaktiviert werden, indem eine leere Zeichenfolge ('') für ihren Wert angegeben wird.

checksum_format: <string> (Standard: siehe sha256)

  • Hashalgorithmus, der für die Dateiprüfung verwendet wird, der mit der angegebenen Archiv-Prüfziffer verbunden ist. Weitere Informationen über Prüfziffern/Kryptographische Hashes finden Sie hier.

alertmgr_installdir: </path/to/installation/dir> (Standard: /opt/alertmanager)

  • Pfad auf dem Zielhost, wohin die alertmanager-Binaries extrahiert werden sollen.

exporter_installdir: </path/to/installation/dir> (Standard: {{ install_dir }}/exporters)

  • Pfad auf dem Zielhost, wohin die Prometheus-Exporter-Binaries extrahiert werden sollen.

alertmgr_archive_url: <Pfad oder URL zu Archiv> (Standard: siehe defaults/main.yml)

  • Adresse eines komprimierten tar oder zip-Archivs, das die alertmanager-Binaries enthält. Diese Methode unterstützt technisch die Installation jeder verfügbaren Version von alertmanager. Links zu den offiziellen Versionen finden Sie hier.

alertmgr_archive_checksum: <Pfad oder URL zur Prüfziffer> (Standard: siehe defaults/main.yml)

  • Adresse einer Prüfziffer-Datei zur Überprüfung der Datenintegrität des angegebenen alertmanager-Archivs. Obwohl empfohlen und allgemein als bewährte Praxis angesehen, ist es nicht erforderlich, eine Prüfziffer anzugeben, und kann deaktiviert werden, indem eine leere Zeichenfolge ('') für ihren Wert angegeben wird.

alertmgr_checksum_format: <string> (Standard: siehe sha256)

  • Hashalgorithmus, der für die Dateiprüfung verwendet wird, der mit der angegebenen Archiv-Prüfziffer verbunden ist. Weitere Informationen über Prüfziffern/Kryptographische Hashes finden Sie hier.

filesd_path: </path/to/file-sd-files> (Standard: {{ install_dir }}/filesd)

  • Pfad auf dem Zielhost, wo die Prometheus-Datei-Entdeckungsdateien standardmäßig gespeichert werden sollen.

rules_path: </path/to/rule-files> (Standard: {{ install_dir }}/rules.d)

  • Pfad auf dem Zielhost, wo die Prometheus-Regeldateien standardmäßig gespeichert werden sollen.

templates_path: </path/to/alertmanager-template-files> (Standard: {{ alertmgr_installdir }}/templates)

  • Pfad auf dem Zielhost, wo die Alertmanager-Vorlagendateien standardmäßig gespeichert werden sollen.

Konfiguration

Mit dieser Rolle wird die Konfiguration einer prometheus-Installation nach den folgenden Komponenten organisiert:

  • Konfiguration des Prometheus-Dienstes (prometheus.yml)
  • Datei-Dienstentdeckung (file_sd - *.[json|yml])
  • Aufnahme- und Alarmierungsregeln (rule_files - *.[json|yml])
  • Konfiguration des Alertmanager-Dienstes (alertmanager.yml)
  • Vorlagendateien des Alertmanagers (*.tmpl)

Jede Konfiguration kann innerhalb der folgenden Variablen ausgedrückt werden, um die Inhalte und Einstellungen der zum Rendern bestimmten Konfigurationsdateien anzupassen:

config_dir: </path/to/configuration/dir> (Standard: {{ install_dir }})

  • Pfad auf dem Zielhost, wo die prometheus-Konfigurationsdateien gerendert werden sollen.

data_dir: </path/to/data/dir> (Standard: /var/data/prometheus)

  • Pfad auf dem Zielhost, wo prometheus Daten speichert.

alertmgr_configdir: </path/to/configuration/dir> (Standard: {{ alertmgr_installdir }})

  • Pfad auf dem Zielhost, wo die alertmanager-Konfigurationsdateien gerendert werden sollen.

alertmgr_datadir: </path/to/data/dir> (Standard: /var/data/alertmanager)

  • Pfad auf dem Zielhost, wo alertmanager Daten speichert.

Prometheus-Dienstkonfiguration

Die Konfiguration des Prometheus-Dienstes kann im Hash prometheus_config ausgedrückt werden, der eine Reihe von Schlüssel-Wert-Paaren enthält, die eine von mehreren Abschnitten darstellen, die verschiedene Abfragetermine (Quellen, aus denen Metriken gesammelt werden sollen), Dienstentdeckungsmechanismen, Aufnahme-/Alarmregeln und Konfigurationen für die Anbindung an remote Lese-/Schreibsysteme, die vom Prometheus-Dienst verwendet werden.

Die Werte dieser Schlüssel sind in der Regel Dicts oder Listen von Dicts, die selbst eine Reihe von Schlüssel-Wert-Paaren enthalten, die die zugehörigen Spezifikationen/Einstellungen darstellen (z.B. das Abfrageintervall oder die Häufigkeit, mit der Metriken von Zielen weltweit abgerufen werden sollen) für jeden Abschnitt. Folgendes bietet einen Überblick und Beispiele für die Konfigurationen zur Referenz.

:global

[prometheus_config:] global: <key: value,...> (Standard: siehe defaults/main.yml)

  • Gibt Parameter an, die gültig sind und als Standardwerte in allen anderen Kontexten der Konfiguration dienen. Weitere Einzelheiten finden Sie hier.
Beispiel
 prometheus_config:
   global:
     # Wie häufig die Ziele standardmäßig abgefragt werden.
     scrape_interval: 15s
     # Wie lange ein Abfrageanforderung Zeit hat, um abzubrechen.
     scrape_timeout: 30s
     # Wie häufig Regeln bewertet werden.
     evaluation_interval: 30s
     # Die Labels, die jedem Zeitreihe oder Alarm hinzugefügt werden sollen, wenn die Kommunikation mit 
     # externen Systemen (Föderation, externe Speicherung, Alertmanager) erfolgt.
     external_labels:
       monitor: example
       foo: bar
:scrape_configs

[prometheus_config:] scrape_configs: <list-of-dicts> (Standard: siehe defaults/main.yml)

  • Gibt eine Reihe von Zielen und Parametern an, die beschreiben, wie sie abgerufen werden sollen, organisiert in Jobs.

Ziele können statisch konfiguriert oder dynamisch entdeckt werden, indem einer der unterstützten Dienstentdeckungsmechanismen verwendet wird. Weitere Einzelheiten finden Sie hier sowie hier für eine Liste der unterstützten Dienstentdeckungsmethoden.

Beispiel
 prometheus_config:
   scrape_configs:
     - job_name: static-example
       static_configs:
       - targets: ['localhost:9090', 'localhost:9191']
         labels:
           example: label
     - job_name: kubernetes-example
       kubernetes_sd_configs:
       - role: endpoints
         api_server: 'https://localhost:1234'
         namespaces:
           names:
             - default
:rule_files

[prometheus_config:] rule_files: <list> (Standard: siehe defaults/main.yml)

  • Gibt eine Liste von glob-ähnlichen Muster an, die die Dateinamen und Pfade angeben.

Regeln und Alarme werden aus allen übereinstimmenden Dateien gelesen. Regeln fallen in eine von zwei Kategorien: Aufnahme- und Alarmierungsregeln. Weitere Einzelheiten zu den Aufnahmeregeln finden Sie hier und zu den Alarmierungsregeln finden Sie hier.

Beispiel
 prometheus_config:
   rule_files:
   - "example.yml"
   - "example_rules/*"
:remote_read

[prometheus_config:] remote_read: <list-of-dicts> (Standard: siehe defaults/main.yml)

  • Gibt Einstellungen an, die sich auf die Remote-Lese-Funktion beziehen.

Weitere Einzelheiten finden Sie hier. Eine Liste verfügbarer Remote-Lese-/Speicherplugins/Integrationen finden Sie unter diesem Link.

Beispiel
 prometheus_config:
   remote_read:
   - url: http://remote1/read
     read_recent: true
     name: default
   - url: http://remote2/read
     read_recent: false
     name: read_special
     required_matchers:
       job: special
     tls_config:
       cert_file: valid_cert_file
       key_file: valid_key_file
:remote_write

[prometheus_config:] remote_write: <list-of-dicts> (Standard: siehe defaults/main.yml)

  • Gibt Einstellungen an, die sich auf die Remote-Write-Funktion beziehen.

Weitere Einzelheiten finden Sie hier. Eine Liste verfügbarer Remote-Write-/Speicherplugins/Integrationen finden Sie unter diesem Link.

Beispiel
 prometheus_config:
   remote_write:
   - name: drop_expensive
     url: http://remote1/push
     write_relabel_configs:
     - source_labels: [__name__]
       regex: expensive.*
       action: drop
   - name: rw_tls
     url: http://remote2/push
     tls_config:
       cert_file: valid_cert_file
       key_file: valid_key_file
:alerting

[prometheus_config:] alerting: <key: value,...> (Standard: siehe defaults/main.yml)

  • Gibt Einstellungen an, die sich auf den Alertmanager beziehen, sowie Alertmanager-Instanzen, an die der Prometheus-Server seine Alarme sendet.

Dieser Abschnitt enthält die Parameter zur Konfiguration der Kommunikation mit diesen Alertmanagern. Alertmanager können entweder statisch über den Parameter statische Konfiguration oder dynamisch über einen der unterstützten Dienstentdeckungsmechanismen konfiguriert werden. Weitere Einzelheiten finden Sie hier.

Beispiel
 prometheus_config:
   alerting:
     alertmanagers:
     - scheme: https
       static_configs:
     - targets:
       - "1.2.3.4:9093"
       - "1.2.3.5:9093"

Datei-Dienstentdeckung

Die dateibasierte Dienstentdeckung bietet eine allgemeinere Möglichkeit, statische Ziele zu konfigurieren und dient als Schnittstelle zur Einbindung benutzerdefinierter Dienstentdeckungsmechanismen. Sie liest eine Reihe von Dateien, die eine Liste von null oder mehr <static_config>-s enthalten. Änderungen an allen definierten Dateien werden über Dateiwatches erkannt und sofort angewendet. Dateien können im YAML- oder JSON-Format bereitgestellt werden. Nur Änderungen, die zu gut geformten Zielgruppen führen, werden angewendet. Weitere Einzelheiten finden Sie hier.

prometheus_file_sd: <list-of-dicts> (Standard: [])

  • Gibt die Prometheus-Datei_sd-Konfigurationen an, die gerendert werden sollen.

Mit dieser Rolle können die Einstellungen der dateibasierten Dienstentdeckung innerhalb des Hashes prometheus_file_sd ausgedrückt werden, der eine Liste von Dictionarien enthält, die den Pfad, den Namen und die Konfigurationsinhalte einer yaml- oder json-Datei kapseln, die von Prometheus für die dateibasierte Entdeckung geladen werden soll.

[prometheus_file_sd : <entry>:] name: <string> (Standard: KEINE - erforderlich)

  • Name der Datei_sd-Datei, die gerendert werden soll.

[prometheus_file_sd : <entry>:] path: <string> (Standard: {{ install_dir }}/file_sd)

  • Pfad der Datei_sd-Datei, die gerendert werden soll.

[prometheus_file_sd : <entry>:] config: <list-of-dicts> (Standard: KEINE - erforderlich)

  • Liste von Dictionarien, die die Einstellungen angeben, die eine Reihe von statischen Zielen in der Datei_sd-Datei angeben.
Beispiel
 prometheus_file_sd:
 - name: example-file.slow.json
   config:
   - targets: ["host1:1234"]
     labels:
       test-label: example-slow-file-sd
 - name: file.yml
   path: /etc/prometheus/file_sd
   config:
   - targets: ["host2:1234"]

NB: Eine zugehörige file_sd-Dienstentdeckung-Scrape_Config wird erwartet, um innerhalb der prometheus.yml-Datei für den erfolgreichen Ladevorgang enthalten zu sein.

Regeldateien

Prometheus unterstützt zwei Arten von Regeln, die konfiguriert und dann in regelmäßigen Abständen bewertet werden können: Aufnahmeregeln und Alarmierungsregeln. Aufnahmeregeln ermöglichen es Ihnen, häufig benötigte oder rechenintensive Ausdrücke im Voraus zu berechnen und ihr Ergebnis als eine neue Reihe von Zeitreihen zu speichern. Alarmierungsregeln ermöglichen es Ihnen, Alarmbedingungen basierend auf Ausdrücken der Prometheus-Ausdruckssprache zu definieren und Benachrichtigungen über auslösende Alarme an einen externen Dienst zu senden. Weitere Einzelheiten finden Sie hier.

prometheus_rule_files: <list-of-dicts> (Standard: [])

  • Gibt die Prometheus-Regeldateien an, die gerendert werden sollen.

Mit dieser Rolle können sowohl Aufnahmeregeln als auch Alarmierungsregeln innerhalb des Hashes prometheus_rule_files ausgedrückt werden, der eine Liste von Dictionarien enthält, die den Pfad, den Namen und die Konfigurationsinhalte einer yaml- oder json-Datei kapseln, die von Prometheus zum Festlegen von Regeln geladen werden soll.

[prometheus_rule_files : <entry>:] name: <string> (Standard: KEINE - erforderlich)

  • Name der Regeldatei, die gerendert werden soll.

[prometheus_rule_files : <entry>:] path: <string> (Standard: {{ install_dir }}/rules.d)

  • Pfad der Regeldatei, die gerendert werden soll.

[prometheus_rule_files : <entry>:] config: <list-of-dicts> (Standard: KEINE - erforderlich)

  • Liste von Dictionarien, die die Einstellungen zur Angabe einer Reihe von Regelgruppen in der Regeldatei darstellen.
Beispiel
prometheus_rule_files:
- name: example-rules.yml
 config:
   groups:
   - name: recording rule example
     rules:
     - record: job:http_inprogress_requests:sum
       expr: sum(http_inprogress_requests) by (job)
- name: nondefault-path-example-rules.yml
 path: /etc/prometheus/rules.d
 config:
   groups:
   - name: alerting rule example
     rules:
     - alert: HighRequestLatency
       expr: job:request_latency_seconds:mean5m{job="myjob"} > 0.5
       for: 10m
       labels:
         severity: page
       annotations:
         summary: High request latency

NB: Eine zugehörige rule_files-Sektion wird erwartet, um innerhalb der prometheus.yml-Datei für den erfolgreichen Ladevorgang enthalten zu sein.

Alertmanager-Dienstkonfiguration

Die Konfiguration des Alertmanager-Dienstes kann im Hash alertmanager_config ausgedrückt werden, der eine Reihe von Schlüssel-Wert-Paaren enthält, die eine von mehreren Abschnitten darstellen und verschiedene Routen-, Empfänger-, Vorlagen- und Alarmhemmungs-Konfigurationen angeben.

Die Werte dieser Schlüssel sind in der Regel Dicts oder Listen von Dicts, die selbst eine Reihe von Schlüssel-Wert-Paaren enthalten, die die zugehörigen Spezifikationen/Einstellungen darstellen (z. B. die API-URL zur Verwendung für Slack-Benachrichtigungen) für jeden Abschnitt. Folgendes bietet einen Überblick und Beispiele für die Konfigurationen zur Referenz.

:global

[alertmanager_config:] global: <key: value,...> (Standard: siehe defaults/main.yml)

  • Gibt Parameter an, die gültig sind und als Standardwerte in allen anderen Kontexten der Konfiguration dienen. Weitere Einzelheiten finden Sie hier.
Beispiel
 alertmanager_config:
   global:
     # Der Smarthost und der SMTP-Absender, die für E-Mail-Benachrichtigungen verwendet werden.
     smtp_smarthost: 'localhost:25'
     smtp_from: '[email protected]'
     smtp_auth_username: 'alertmanager'
     smtp_auth_password: 'password'
     # Der Authentifizierungstoken für Hipchat.
     hipchat_auth_token: '1234556789'
     # Alternativer Host für Hipchat.
     hipchat_api_url: 'https://hipchat.foobar.org/'
:route

[alertmanager_config:] route: <key: value,...> (Standard: siehe defaults/main.yml)

  • Definiert einen Knoten in einem Routing-Baum und seine Kinder.

Jeder Alarm betritt den Routing-Baum über die konfigurierte oberste Route, die alle Alarme übereinstimmen muss (d.h. keine konfigurierten Abgleichkriterien haben darf). Anschließend durchläuft er die untergeordneten Knoten. Wenn continue auf false gesetzt ist, stoppt er nach dem ersten passenden Kind. Wenn für einen passenden Knoten continue auf true gesetzt ist, wird der Alarm weiterhin mit nachfolgenden Geschwistern abgeglichen. Weitere Einzelheiten finden Sie hier.

Beispiel
 alertmanager_config:
   route:
     receiver: 'default-receiver'
     group_wait: 30s
     group_interval: 5m
     repeat_interval: 4h
     group_by: [cluster, alertname]
     # Alle Alarme, die nicht mit den folgenden untergeordneten Routen übereinstimmen,
     # bleiben am Wurzelknoten und werden an den 'default-receiver' gesendet.
     routes:
       # Alle Alarme mit service=mysql oder service=cassandra
       # werden an den Datenbank-Pager gesendet.
     - receiver: 'database-pager'
       group_wait: 10s
       match_re:
         service: mysql|cassandra
     # Alle Alarme mit dem team=frontend-Label stimmen mit dieser Unterroute überein.
     # Sie werden nach Produkt und Umgebung gruppiert, nicht nach Cluster
     # und alarmname.
     - receiver: 'frontend-pager'
       group_by: [product, environment]
       match:
         team: frontend
:receivers

[alertmanager_config:] inhibit_rules: <list-of-dicts> (Standard: siehe defaults/main.yml)

  • Gibt eine Liste von Benachrichtigungsempfängern an.

Empfänger sind benannte Konfigurationen für eine oder mehrere Benachrichtigungsintegrationen. Weitere Einzelheiten finden Sie hier.

Beispiel
 alertmanager_config:
   receivers:
   - name: 'team-X-mails'
     email_configs:
     - to: '[email protected]'
     pagerduty_configs:
     - service_key: <team-X-key>
     hipchat_configs:
     - auth_token: <auth_token>
       room_id: 85
       message_format: html
       notify: true
:inhibit_rules

[alertmanager_config:] inhibit_rules: <list-of-dicts> (Standard: siehe defaults/main.yml)

  • Gibt eine Liste von Hemmungsregeln an.

Eine Hemmungsregel mute einen Alarm (Ziel), der mit einer Reihe von Abgleichkriterien übereinstimmt, wenn ein Alarm (Quelle) existiert, der mit einer anderen Reihe von Abgleichkriterien übereinstimmt. Weitere Einzelheiten finden Sie hier.

Beispiel
 alertmanager_config:
   inhibit_rules:
   - source_match:
       severity: 'critical'
     target_match:
       severity: 'warning'
     # Wenden Sie die Hemmung an, wenn der Alarmname gleich ist.
     equal: ['alertname', 'cluster', 'service']
:templates

[alertmanager_config:] templates: <list> (Standard: siehe defaults/main.yml)

  • Gibt Dateien und Verzeichnisse an, aus denen Benachrichtigungsvorlagen gelesen werden.

Die letzte Komponente kann einen Wildcard-Matcher verwenden, z.B. templates/*.tmpl. Weitere Informationen zu Benachrichtigungsvorlagen finden Sie hier und eine Referenz zu den Vorlagen finden Sie unter diesem Link.

Beispiel
 alertmanager_config:
   templates:
   - '/etc/alertmanager/template/*.tmpl'

Vorlagen des Alertmanager

Prometheus erstellt und sendet Alarme an den Alertmanager, der dann Benachrichtigungen an verschiedene Empfänger sendet, basierend auf deren Labels. Die an Empfänger gesendeten Benachrichtigungen werden über Vorlagen erstellt. Der Alertmanager wird mit Standardvorlagen geliefert, kann jedoch auch angepasst werden. Weitere Einzelheiten finden Sie hier.

altermanager_templates: <list-of-dicts> (Standard: [])

  • Gibt die Konfiguration der Benachrichtigungsvorlagen des alertmanager an, die gerendert werden sollen.

Mit dieser Rolle können die Einstellungen der Alertmanager-Vorlage innerhalb des Hashes alertmanager_templates ausgedrückt werden, der eine Liste von Dictionarien enthält, die den Pfad, den Namen und die Konfigurationsinhalte einer tmpl-Datei kapseln, die vom Alertmanager geladen werden soll.

[alertmanager_templates : <entry>:] name: <string> (Standard: KEINE - erforderlich)

  • Name der Vorlagendatei, die gerendert werden soll.

[alertmanager_templates : <entry>:] path: <string> (Standard: {{ alertmgr_installdir }}/templates)

  • Pfad der Vorlagendatei, die gerendert werden soll.

[alertmanager_templates : <entry>:] config: <list-of-dicts> (Standard: KEINE - erforderlich)

  • Liste von Dictionarien, die die Einstellungen zur Angabe einer Reihe von Vorlagenkonfigurationen, die gerendert werden sollen.
Beispiel
 alertmanager_templates:
 - name: test
   config:
   - define: "myorg.test.guide"
     template: 'https://internal.myorg.net/wiki/alerts/\{\{ .GroupLabels.app \}\}/\{\{ .GroupLabels.alertname \}\}'
 - name: test2
   path: /etc/alertmanager/templates
   config:
   - define: "myorg.test.text"
     template: 'summary: \{\{ .CommonAnnotations.summary \}\}\ndescription: \{\{ .CommonAnnotations.description \}\}'

NB: Eine zugehörige templates-Konfigurationssektion wird erwartet, um innerhalb der alertmanager.yml-Datei für den erfolgreichen Ladevorgang enthalten zu sein.

Start

Diese Rolle unterstützt das Starten aller Komponenten des Prometheus-Überwachungs- und Alarmierungstoolkit-Ökosystems. Dazu gehören sowohl die Dienste Prometheus und Alertmanager als auch eine Vielzahl von Metrik-Exportern. Das Ausführen jedes Dienstes erfolgt unter Verwendung des Dienstverwaltungswerkzeugs systemd, das die Dienste als Hintergrundprozesse oder Daemons verwaltet, die den Konfigurationen und Ausführungsoptionen des underlying Management-Frameworks unterliegen.

Die folgenden Variablen können angepasst werden, um die systemd- [Service]-Unit-Definition und das Ausführungsprofil/Policy der Dienste zu verwalten:

Prometheus

extra_run_args: <prometheus-cli-options> (Standard: [])

  • Liste von prometheus-Befehlszeilenargumenten, die zur Laufzeit an die Binärdatei übergeben werden, um den Start anzupassen.

Unterstützt die vollständige Ausdrucksfähigkeit der cli von prometheus, ermöglicht diese Variable eine anpassbare Ausführung.

custom_unit_properties: <hash-of-systemd-service-settings> (Standard: [])

  • Hash von Einstellungen, die verwendet werden, um die [Service]-Unit-Konfiguration und die Ausführungsumgebung des Prometheus systemd-Dienstes anzupassen.
Alertmanager

extra_alertmgr_args: <alertmanager-cli-options> (Standard: [])

  • Liste von alertmanager-Befehlszeilenargumenten, die zur Laufzeit an die Binärdatei übergeben werden, um den Start anzupassen.

Unterstützt die vollständige Ausdrucksfähigkeit der cli von alertmanager, ermöglicht diese Variable eine anpassbare Ausführung.

custom_alertmgr_properties: <hash-of-systemd-service-settings> (Standard: [])

  • Hash von Einstellungen, die verwendet werden, um die [Service]-Unit-Konfiguration und die Ausführungsumgebung des Alertmanager systemd-Dienstes anzupassen.
Exporter

prometheus_exporters: <list-of-dicts> (Standard: [])

  • Gibt die Prometheus-Exporter an, die installiert, gestartet und als systemd-Dienste verwaltet werden sollen.

Jeder Exporter-Dict-Eintrag muss mehrere Eigenschaften angeben, einschließlich Name; URL und Listenadresse des Ziel-Exporters für eine ordnungsgemäße Einrichtung und Kommunikation mit einem Prometheus-Server. Andere Eigenschaften zur Anpassung des Betriebs des Exporters können optional über eine extra_args-Variable angegeben werden, die die bereitgestellten Befehlszeilenargumente an die ExecStart-Einstellung der Einheit anhängt. Weitere Einzelheiten finden Sie hier.

[prometheus_exporters : <entry>:] name: <string> (Standard: KEINE - erforderlich)

  • Name des zu installierenden Prometheus-Exporters.

[prometheus_exporters : <entry>:] url: <string> (Standard: KEINE - erforderlich)

  • URL des zu installierenden Prometheus-Exporters.

[prometheus_exporters : <entry>:] description: <string> (Standard: <exporter-name>)

  • Beschreibung oder Dokumentation des Prometheus-Exporters, die innerhalb der Systemd-Einheit des Exporters enthalten ist.

[prometheus_exporters : <entry>:] unit_properties: <hash> (Standard: {})

  • Hash von Einstellungen, die verwendet werden, um die [Service]-Unit-Konfiguration und die Ausführungsumgebung des systemd-Dienstes anzupassen.
Beispiel
 prometheus_exporters:
   - name: node_exporter
     url: https://github.com/prometheus/node_exporter/releases/download/v0.18.1/node_exporter-0.18.1.linux-amd64.tar.gz
     description: https://github.com/prometheus/node_exporter
     unit_properties:
       User: exporter
       Group: exporter
     extra_args:
       - '--web.listen-address=0.0.0.0:9110'
       - '--log.level=debug'

Deinstallation

Unterstützung bei der Deinstallation und dem Entfernen von Artefakten, die zur Bereitstellung erforderlich sind, ermöglicht es Benutzern/Betriebern, einen Zielhost in seinen konfigurierten Zustand vor der Anwendung dieser Rolle zurückzuführen. Dies kann nützlich sein, um Knoten und Rollen wiederzuverwenden und vielleicht einen sanfteren/verwalteten Übergang zwischen Tool-Upgrades zu bieten.

Die folgenden Variablen können angepasst werden, um diesen Deinstallationsprozess zu verwalten:

perform_uninstall: <true | false> (Standard: false)

  • Ob alle Artefakte und Überreste dieser prometheus-Installation auf einem Zielhost deinstalliert und entfernt werden sollen (siehe: handlers/main.yml für Details).

Abhängigkeiten

  • 0x0i.systemd

Beispiel-Playbook

Standardbeispiel:

- hosts: all
  roles:
  - role: 0x0I.prometheus

nur den Prometheus-Dienst installieren und verwalten (Deaktivieren der Alertmanager-Setup):

- hosts: all
  roles:
  - role: 0x0I.prometheus
    vars:
      managed_services: ['prometheus']

bestimmte Version von Prometheus installieren:

- hosts: all
  roles:
  - role: 0x0I.prometheus
    vars:
      archive_url: https://github.com/prometheus/prometheus/releases/download/v2.15.0/prometheus-2.15.0.linux-amd64.tar.gz
      archive_checksum: 1c2175428e7a70297d97a30a04278b86ccd6fc53bf481344936d6573482203b4

Anpassung der Installations-, Konfigurations- und Datendirektorien von Prometheus und Alertmanager:

- hosts: all
  roles:
  - role: 0x0I.prometheus
    vars:
      install_dir: /usr/local
      config_dir: /etc/prometheus
      data_dir: /var/lib/prometheus
      alertmgr_installdir: /usr/local
      alertmgr_configdir: /etc/alertmanager
      alertmgr_datadir: /var/lib/alertmanager

Anpassung der globalen Abfrage- und Auswertungseinstellungen:

- hosts: all
  roles:
  - role: 0x0I.prometheus
    vars:
      prometheus_config:
        global:
          scrape_interval: 30s
          scrape_timeout: 30s
          evaluation_interval: 30s

Anpassung der Konfiguration von Prometheus-Alarmen/Alertmanager:

- hosts: all
  roles:
  - role: 0x0I.prometheus
    vars:
      prometheus_config:
        alerting:
          alertmanagers:
          - scheme: https
            static_configs:
            - targets:
              - "1.2.3.4:9093"

Erstellen von Aufnahme- und Alarmierungsregeln:

- hosts: all
  roles:
  - role: 0x0I.prometheus
    vars:
      prometheus_config:
        rule_files:
        - /etc/prometheus/rules.d/*
      prometheus_rule_files:
      - name: example-rules.yml
        path: /etc/prometheus/rules.d/*
        config:
          groups:
            - name: recording rule example
              rules:
                - record: job:http_inprogress_requests:sum
                  expr: sum(http_inprogress_requests) by (job)
      - name: another-example.yml
        path: /etc/prometheus/rules.d
        config:
          groups:
            - name: alerting rule example
              rules:
                - alert: HighRequestLatency
                  expr: job:request_latency_seconds:mean5m{job="myjob"} > 0.5
                  for: 10m
                  labels:
                    severity: page
                  annotations:
                    summary: High request latency

statische Ziel-Abfrage-Konfiguration mit Abfrage- und Auswertungseinstellungen:

- hosts: all
  roles:
  - role: 0x0I.prometheus
    vars:
      prometheus_config:
        scrape_configs:
        - job_name: static-example
           static_configs:
           - targets: ['localhost:9090', 'localhost:9191']
             labels:
               my:   label
               your: label
          scrape_interval: 10s
          scrape_timeout: 10s
          evaluation_interval: 10s

file_sd dateibasierte Abfrage-Konfiguration mit Abfrage- und Auswertungseinstellungen:

- hosts: all
  roles:
  - role: 0x0I.prometheus
    vars:
      prometheus_config:
        scrape_configs:
        - job_name: file-sd-example
            file_sd_configs:
            - files:
              - foo/*.slow.json
              - single/file.yml
              refresh_interval: 10m
            - files:
             - bar/*.yml
      prometheus_file_sd:
      - name: example-file.slow.json
        path: foo
        config:
        - targets: ["host1:1234"]
          labels:
            test-label: example-slow-file-sd
      - name: foo.yml
        path: bar
        config:
        - targets: ["host2:1234"]
      - name: file.yml
        path: single
        config:
        - targets: ["host3:1234"]

dns-basierte Zielabfrage-Konfiguration:

- hosts: all
  roles:
  - role: 0x0I.prometheus
    vars:
      prometheus_config:
        scrape_configs:
        - job_name: dns-example
          dns_sd_configs:
          - refresh_interval: 15s
            names:
            - first.dns.address.domain.com
            - second.dns.address.domain.com
          - names:
            - third.dns.address.domain.com

kubernetes Zielabfrage-Konfiguration mit TLS- und Basisauthentifizierungseinstellungen:

- hosts: all
  roles:
  - role: 0x0I.prometheus
    vars:
      prometheus_config:
        scrape_configs:
        - job_name: kubernetes-example
          kubernetes_sd_configs:
          - role: endpoints
            api_server: 'https://localhost:1234'
            tls_config:
              cert_file: valid_cert_file
              key_file: valid_key_file
            basic_auth:
              username: 'myusername'
              password: 'mysecret'

ec2 Zielabfrage-Konfiguration:

- hosts: all
  roles:
  - role: 0x0I.prometheus
    vars:
      prometheus_config:
        scrape_configs:
        - job_name: ec2-example
          ec2_sd_configs:
          - region: us-east-1
            access_key: access
            secret_key: mysecret
            profile: profile
            filters:
            - name: tag:environment
              values:
              - prod
            - name: tag:service
              values:
              - web
              - db

openstack Zielabfrage-Konfiguration:

- hosts: all
  roles:
  - role: 0x0I.prometheus
    vars:
      prometheus_config:
        scrape_configs:
        - job_name: openstack-example
          openstack_sd_configs:
          - role: instance
            region: RegionOne
            port: 80
            refresh_interval: 1m

azure Zielabfrage-Konfiguration:

- hosts: all
  roles:
  - role: 0x0I.prometheus
    vars:
      prometheus_config:
        scrape_configs:
        - job_name: azure-example
          azure_sd_configs:
    -       environment: AzurePublicCloud
            authentication_method: OAuth
            subscription_id: 11AAAA11-A11A-111A-A111-1111A1111A11
            tenant_id: BBBB222B-B2B2-2B22-B222-2BB2222BB2B2
            client_id: 333333CC-3C33-3333-CCC3-33C3CCCCC33C
            client_secret: mysecret
            port: 9100

marathon Zielabfrage-Konfiguration:

- hosts: all
  roles:
  - role: 0x0I.prometheus
    vars:
      prometheus_config:
        scrape_configs:
        - job_name: marathon-example
          marathon_sd_configs:
          - servers:
            - 'https://marathon.example.com:443'
            auth_token: "mysecret"

consul Zielabfrage-Konfiguration:

- hosts: all
  roles:
  - role: 0x0I.prometheus
    vars:
      prometheus_config:
        scrape_configs:
        - job_name: consul-example
          consul_sd_configs:
          - server: 'localhost:1234'
            token: mysecret
            services: ['nginx', 'cache', 'mysql']
            tags: ["canary", "v1"]
            node_meta:
              rack: "123"
            allow_stale: true
            scheme: https

Lizenz

MIT

Autoreninformationen

Diese Rolle wurde 2019 von O1.IO erstellt.

Über das Projekt

Prometheus - a multi-dimensional time-series data monitoring and alerting toolkit

role alerting monitoring prometheus
Installieren
ansible-galaxy install 0x0i.prometheus
GitHub Repository
0 Sterne
2 Forks
0 Offene Issues
Lizenz
Unknown
Downloads
923
Besitzer