Monitoring mit Prometheus - ein erster Test

Datum 26.04.2018

Als ich auf der Suche nach einem Monitoring war, welches nicht den Apache2 als Voraussetzung hat, lief mir Prometheus über den Weg.

Was mich überzeugt hat war die Einfachheit mit der sich ein Monitoring von mehren Nodes innerhalb weniger Minuten realisieren lässt.

Einer der Erfolgsfaktoren von Prometheus, das konzeptionell auf Googles internem Borgmon-System beruht, ist der modulare Aufbau. Das zentrale Modul ist der Prometheus-Server, der eine Time-Series-Datenbank und die zugehörige Abfragesprache PromQL bereitstellt. Die Datenbank speichert Folgen von 64-Bit-Fließkommazahlen zusammen mit dem jeweiligen Zeitstempel, der anzeigt, wann der Wert in die Datenbank aufgenommen wurde. Mit PromQL lassen sich die Zeitreihen statistisch auswerten und miteinander in Relation bringen.

Vorbereitungen

Die drei wichtigsten Prometheus-Komponenten sind:

Exporter: Tools, die Metriken über spezifische Komponenten wie Betriebssysteme oder Datenbanken bereitstellen. Die Prometheus-Dokumentation weist auf mehrere Exporter hin.
Grafana: eine webbasierte grafische Benutzeroberfläche mit Dashboard-Funktionen.
Alertmanager: kümmern sich unter anderem um das Routing von Alarmen zu Pager-Diensten und um das Unterdrücken sich wiederholender Alarme.

Auf dem Server, welcher das Prometheus-Dashboard darstellen soll, laden wir uns von der offiziellen Webseite prometheus.io/download herunter:

wget https://github.com/prometheus/node_exporter/releases/download/v0.16.0-rc.2/node_exporter-0.16.0-rc.2.linux-amd64.tar.gz
wget https://github.com/prometheus/prometheus/releases/download/v2.2.1/prometheus-2.2.1.linux-amd64.tar.gz

und entpacken diese anschließend:

tar -xzf node_exporter-0.16.0-rc.2.linux-amd64.tar.gz
tar -xzf prometheus-2.2.1.linux-amd64.tar.gz

Der node_exporter ist das Modul, welches Hardware-Metriken sammelt. Es gibt noch viele weitere Module für diverse Dienste.
Eine Übersicht findet man hier: prometheus.io

Systeme einrichten

Prometheus einrichten

Wir beginnen auf dem eigentlichen Prometheus Server, welcher das Dashboard darstellt und welchen wir natürlich auch gleich überwachen wollen.
Dazu wechseln wir in das Verzeichnis node_exporter-0.16.0-rc.2.linux-amd64 und kopieren (oder auch verschieben) die dort enthaltene Binary nach /usr/local/bin
cp node_exporter /usr/local/bin/

und um den Dienst zu steuern erstellen wir eine passende Systemd-Service-Datei unter:
/etc/systemd/system/node_exporter.service
welche den folgenden Inhalt hat:

[Unit]
Description=Export Metrics to Prometheus
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/node_exporter 

[Install]
WantedBy=multi-user.target

nun sollte sich der Dienst bequem per systemctl start node_exporter starten lassen.
Ein systemctl status node_exporter sollte nun folgendes zeigen:

● node_exporter.service - Export Metrics to Prometheus
   Loaded: loaded (/etc/systemd/system/node_exporter.service; disabled; vendor preset: enabled)
   Active: active (running) since Thu 2018-04-26 17:42:52 UTC; 5min ago
 Main PID: 2422 (node_exporter)
    Tasks: 15
   Memory: 9.0M
      CPU: 2.471s
   CGroup: /system.slice/node_exporter.service
           └─2422 /usr/local/bin/node_exporter

Apr 26 17:42:52 ubuntu02 node_exporter[2422]: time="2018-04-26T17:42:52Z" level=info msg=" - stat" source="node_exporter.go:97"
Apr 26 17:42:52 ubuntu02 node_exporter[2422]: time="2018-04-26T17:42:52Z" level=info msg=" - textfile" source="node_exporter.go:97"
Apr 26 17:42:52 ubuntu02 node_exporter[2422]: time="2018-04-26T17:42:52Z" level=info msg=" - time" source="node_exporter.go:97"
Apr 26 17:42:52 ubuntu02 node_exporter[2422]: time="2018-04-26T17:42:52Z" level=info msg=" - timex" source="node_exporter.go:97"
Apr 26 17:42:52 ubuntu02 node_exporter[2422]: time="2018-04-26T17:42:52Z" level=info msg=" - uname" source="node_exporter.go:97"
Apr 26 17:42:52 ubuntu02 node_exporter[2422]: time="2018-04-26T17:42:52Z" level=info msg=" - vmstat" source="node_exporter.go:97"
Apr 26 17:42:52 ubuntu02 node_exporter[2422]: time="2018-04-26T17:42:52Z" level=info msg=" - wifi" source="node_exporter.go:97"
Apr 26 17:42:52 ubuntu02 node_exporter[2422]: time="2018-04-26T17:42:52Z" level=info msg=" - xfs" source="node_exporter.go:97"
Apr 26 17:42:52 ubuntu02 node_exporter[2422]: time="2018-04-26T17:42:52Z" level=info msg=" - zfs" source="node_exporter.go:97"
Apr 26 17:42:52 ubuntu02 node_exporter[2422]: time="2018-04-26T17:42:52Z" level=info msg="Listening on :9100" source="node_exporter.go:111"

Damit werden nun aktiv Daten gesammelt und auf Port 9100 für Abfragen des Prometheus-Servers bereitgestellt.

Nun richten wir den Prometheus Server ein…
Hierzu wechseln wir in das Verzeichnis prometheus-2.2.1.linux-amd64 und dort bearbeiten wir die Datei prometheus.yml wie folgt:

global:
        scrape_interval: 5s
scrape_configs: 
        - job_name: node01
          static_configs:
                  - targets: ["127.0.0.1:9100"]      
        - job_name: prometheus
          static_configs:
                  - targets: ["127.0.0.1:9090"]      
        - job_name: node02
          static_configs:
                  - targets: ["ubuntu01:9100"]      
        - job_name: node03
          static_configs:
                  - targets: ["ubuntu02:9100"]      
        - job_name: node04
          static_configs:
                  - targets: ["fedora01:9100"]

Das scape_interval gibt das Zeitintervall an, in welchem die Nodes geprüft werden. Danach folgen die Angaben der verschiedenen Nodes und dort lassen sich auch Aliase für die einzelnen Nodes festlegen. Ich habe hierbei die Bezeichnung node0x gewählt, wobei der Prometheus -Server auch gleichzeitig node01 ist.
Ich habe hierbei bei dem Parameter targets: die DNS-Namen meiner Systeme angegeben, welche natürlich auf eine entsprechende IP-Adresse auflösen müssen.

Da es sich bei der Konfigurationsdatei um eine Yaml-Datei handelt muss man sehr mit dem Einrücken der einzelnen Passagen aufpassen, da sonst der Prometheus-Dienst nicht startet.

Das Dashboard erreicht man unter <Prometheus-Server>:9090
Dort lassen sich die abzufragenden Metriken der einzelnen, oder aller Nodes auf einmal, anzeigen.

Einen Node für Prometheus einrichten

Hierzu laden wir nur den Node_Exporter herunter und richten diesen wie bereits weiter oben beschrieben mit einem entsprechenden Systemd-Start-Script ein.
Auch diesen neuen Node tragen wir in die Prometheus-Config ein und starten den Prometheus -Dienst neu.
Mehr ist nicht zu tun um einen neuen Node hinzuzufügen.
Welche aktuellen Werte die abgefragten Metriken haben, kann man auch auf jedem Node einzeln abfragen.
Sofern der entsprechende Port nicht durch eine Firewall gesperrt ist, kann man die URL aufrufen: http://<Node-IP>:9100/metrics

Einen Reverse-Proxy einrichten

Man kann das Dashboard per default durch den Aufruf auf Port 9090 des Prometheus -Servers aufrufen, alternativ kann man auch einen Reverse-Proxy einrichten. Des weiteren beherrscht Prometheus momentan keine Möglichkeit eine Login-Maske davor zu schalten. D.h. Standardmäßig ist das Dashboard frei aufrufbar, von daher empfiehlt es sich immer einen Reverse-Proxy davorzuschalten.
Hierzu verwende ich Caddy als Reverse-proxy , da dieser sich extrem einfach konfigurieren lässt.

Eine entsprechende beispielhafte Konfigurationsdatei für Caddy könnte wie folgt aussehen:

$ cat Caddyfile 
funny.tld:80 {
        proxy / http://10.34.201.165:9090 { }
}

Exporter-Module

Wie bereits erwähnt gibt es Monitoring-Module für diverse Dienste und Dateisysteme, z.B.: diverse DBs (z.B.mysqld, CouchDB, Oracle), ceph, glustermemcached, redis, etc…

Diese Exporter findet man auf der offiziellen Webseite https://prometheus.io/docs/instrumenting/exporters/.
Es gibt auch bereits Tools die eine entsprechende Unterstützung für Prometheus mitbringen, z.B. der Webserver Caddy

Caddy kann durch das hinzufügen fes folgenden Abschnitts in die Konfigurationsdatei Caddyfile Metriken für Prometheus abrufbar machen:

prometheus {
                address 0.0.0.0:9180
        }

Nun sollte auf dem entsprechenden Port ein Caddy lauschen…

$ ss -tulpn | grep 9180
tcp    LISTEN     0      128      :::9180                 :::*                   users:(("caddy",pid=32683,fd=8))

Nachdem in der Config von Prometheus der entsprechende Eintrag für den Host vorgenommen wurde und der Prometheus-Dienst neu gestartet wurde, sollten nach kurzer Zeit die ersten erfassten Werte im Dashboard auftauchen.

Dieser Vorgang funktioniert auch problemlos auf einem RaspberryPI, da sowohl die Exporter-Module als auch der Caddy-Webserver in GO geschrieben sind und somit auch auf der ARM-Architektur kompiliert werden können.

Bei allen anderen Exportern sollte man in der jeweiligen Dokumentation nachschauen wie diese gestartet werden und auf welchem Port die Daten bereitgestellt werden.

Achtung: Man sollte hierbei immer beachten, dass es (soweit mir bekannt ist) keine Authentifizierung zwischen den Prometheus-Server und den Exportern gibt. Das heißt, dass so ziemlich jeder Prometheus-Server, welcher die Adresse und den Port kennt Daten von den entsprechenden Exportern abrufen kann.
Dem kann man mit z.B. entsprechenden Restriktionen in der Firewall entgegenwirken.

Autor Rasputin
Kategorien Linux, Monitoring