TOC

So installieren Sie Prometheus mit Docker unter Ubuntu 14.04

Ein Artikel von Prometheus Mitschöpfer Julius Volz

Einführung

Prometheus ist ein Open-Source-Überwachungssystem und eine Zeitreihendatenbank. Es befasst sich mit vielen Aspekten der Überwachung, z. B. dem Generieren und Erfassen von Metriken, dem grafischen Darstellen der resultierenden Daten in Dashboards und dem Warnen bei Anomalien. Um dies zu erreichen, bietet es eine Vielzahl von Komponenten, die separat ausgeführt, aber in Kombination verwendet werden.

Docker bietet Ihnen die Möglichkeit, Serverprozesse mithilfe von Linux-Containern (oder anderen Kapselungstechnologien) zu kapseln, damit sie einfacher verwaltet und voneinander isoliert werden können. Weitere Informationen zu Docker finden Sie unter The Docker Ecosystem: Eine Einführung in allgemeine Komponenten.

In diesem Tutorial erfahren Sie, wie Sie drei wichtige Komponenten für die Verwendung von Prometheus in Docker installieren. Diese sind:

  • Ein Prometheus-Server zum Sammeln und Abfragen von Metriken

  • Ein Node Exporter zum Exportieren von Systemmetriken in ein Prometheus-kompatibles Format

  • Grafana, ein webbasierter Builder für grafische Dashboards, der unter anderem Prometheus unterstützt

Es gibt viel mehr Komponenten im Prometheus-Ökosystem, aber diese drei bieten einen guten Ausgangspunkt für die Verwendung von Prometheus.

Voraussetzungen

Um diesem Tutorial zu folgen, benötigen Sie:

Schritt 1 - Prometheus installieren

In diesem Abschnitt wird erläutert, wie Sie den Prometheus-Hauptserver mit Docker installieren. Stellen Sie sicher, dass Docker gemäß den * Voraussetzungen * installiert ist, bevor Sie fortfahren. Der Prometheus-Server ist das zentrale Element des Prometheus-Ökosystems. Er ist für das Sammeln und Speichern von Metriken sowie für die Verarbeitung von Ausdrucksabfragen und das Generieren von Warnungen zuständig.

Docker-Container-Images für alle Prometheus-Komponenten werden unter der Organisation * https: //hub.docker.com/u/prom/ [prom] * in Docker Hub gehostet. Wenn Sie das Docker-Image "+ prom / prometheus " ohne weitere Optionen ausführen, wird der Prometheus-Server mit einer Beispielkonfigurationsdatei gestartet, die sich unter " / etc / prometheus / prometheus.yml " im Container befindet. Es wird auch ein https://www.digitalocean.com/community/tutorials/how-to-work-with-docker-data-volumes-on-ubuntu-14-04[Docker-Datenvolumen] verwendet, das unter ` / prometheus + eingehängt ist `im Container, um gesammelte Metrikdaten zu speichern. Dieses Datenvolumenverzeichnis ist eigentlich ein Verzeichnis auf dem Host, das Docker beim ersten Start des Containers automatisch erstellt. Die darin enthaltenen Daten bleiben zwischen Neustarts desselben Containers erhalten.

Es gibt mehrere Möglichkeiten, die Standardkonfigurationsdatei zu überschreiben. Beispielsweise kann eine benutzerdefinierte Konfigurationsdatei vom Host-Dateisystem als Docker-Daten-Volume in den Container übergeben werden, oder Sie können einen abgeleiteten Docker-Container mit Ihrer eigenen Konfigurationsdatei erstellen, die in das Container-Image eingebrannt ist. In diesem Lernprogramm wird eine Konfigurationsdatei vom Hostsystem übergeben.

Es gibt verschiedene Muster für die Organisation der Speicherung von Metriken. In diesem Tutorial verwenden wir das Standardverhalten des Docker-Images, nämlich https://www.digitalocean.com/community/tutorials/how-to-work-with-docker-data-volumes-on-ubuntu-14-04 [Docker-Datenvolumen] zum Speichern der Metriken. Alternativ können Sie einen Datenvolumencontainer erstellen, wenn dies Ihren Anforderungen besser entspricht.

Erstellen Sie zunächst eine minimale Prometheus-Konfigurationsdatei auf dem Host-Dateisystem unter + ~ / prometheus.yml +:

nano ~/prometheus.yml

Fügen Sie der Datei den folgenden Inhalt hinzu (ersetzen Sie "++" durch die IP-Adresse Ihres Droplets):

~ / prometheus.yml

# A scrape configuration scraping a Node Exporter and the Prometheus server
# itself.
scrape_configs:
 # Scrape Prometheus itself every 5 seconds.
 - job_name: 'prometheus'
   scrape_interval: 5s
   target_groups:
     - targets: ['localhost:9090']

 # Scrape the Node Exporter every 5 seconds.
 - job_name: 'node'
   scrape_interval: 5s
   target_groups:
     - targets: [':9100']

Diese Beispielkonfiguration bewirkt, dass Prometheus Metriken von sich selbst (da Prometheus auch Metriken über sich selbst in einem Prometheus-kompatiblen Format verfügbar macht) sowie von einem Node Exporter, den wir später einrichten werden. Während Prometheus innerhalb seines Containers eine Verbindung mit dem Hostnamen "+ localhost +" herstellen kann, muss der Node Exporter mithilfe der externen IP-Adresse Ihres Servers gelöscht werden, da der Node Exporter in einem separaten Container mit einem separaten Netzwerk-Namespace ausgeführt wird.

Starten Sie den Prometheus Docker-Container mit der externen Konfigurationsdatei:

docker run -d -p 9090:9090 -v ~/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus -config.file=/etc/prometheus/prometheus.yml -storage.local.path=/prometheus -storage.local.memory-chunks=10000

Wenn Sie diesen Befehl zum ersten Mal ausführen, wird das Docker-Image vom Docker Hub abgerufen.

Dieser Befehl ist ziemlich lang und enthält viele Befehlszeilenoptionen. Schauen wir uns das genauer an:

  • Die Option "+ -d " startet den Prometheus-Container im getrennten Modus, dh, der Container wird im Hintergrund gestartet und nicht durch Drücken von " STRG + C +" beendet.

  • Die Option "+ -p 9090: 9090 +" macht den Prometheus-Web-Port (9090) verfügbar und macht ihn über die externe IP-Adresse des Host-Systems erreichbar.

  • Mit der Option "+ -v […​] " wird die Konfigurationsdatei " prometheus.yml " vom Host-Dateisystem an der Stelle im Container abgelegt, an der Prometheus sie erwartet (" /etc/prometheus/prometheus.yml +"). .

  • Die Option "+ -config.file +" wird entsprechend dem Speicherort der Prometheus-Konfigurationsdatei in im Container festgelegt.

  • Die Option "+ -storage.local.path" konfiguriert den Speicherort der Metriken im Container.

  • Schließlich passt die Option "+ -storage.local.memory-chunks +" die Speichernutzung von Prometheus an die sehr geringe RAM-Größe (nur 512 MB) und die geringe Anzahl gespeicherter Zeitreihen in diesem Lernprogramm (knapp 1000) an. Es weist Prometheus an, nur 10000 Sample-Chunks im Speicher zu belassen (ungefähr 10 Chunks pro Serie), anstatt der Standardeinstellung 1048576. * Diesen Wert müssen Sie unbedingt anpassen *, wenn Sie Prometheus auf einem Computer mit mehr RAM ausführen und mehr Zeitreihen speichern. Weitere Informationen hierzu finden Sie in der storage documentation von Prometheus.

Mit dem folgenden Befehl können Sie alle ausgeführten Docker-Container auflisten:

docker ps

Für den Prometheus Docker-Container wird beispielsweise Folgendes angezeigt:

Output of `docker ps`CONTAINER ID        IMAGE                COMMAND                  CREATED             STATUS              PORTS                    NAMES
6a89ac39911e        prom/prometheus      "/bin/prometheus -con"   2 hours ago         Up 2 hours          0.0.0.0:9090->9090/tcp   stoic_pike

Mit der Container-ID, die in der Ausgabe von + docker ps + angezeigt wird, können Sie die Protokolle des aktiven Prometheus-Servers mit dem folgenden Befehl überprüfen:

docker logs

In unserem Beispiel wäre der Befehl:

docker logs

Um herauszufinden, wo auf dem Dateisystem des Hosts das Messwertspeicher-Volume gespeichert ist, können Sie Folgendes mit Ihrem ausführen:

docker inspect

Dadurch werden Informationen zur Konfiguration Ihres Containers ausgegeben, einschließlich der Hostpfade aller bereitgestellten Docker-Volumes.

Suchen Sie in der Ausgabe einen Abschnitt, der ungefähr so ​​aussieht:

Output of `docker inspect`...
"Mounts": [
   {
       "Source": "/home/sammy/prometheus.yml",
       "Destination": "/etc/prometheus/prometheus.yml",
       "Mode": "",
       "RW": true
   },
   {
       "Name": "821b0abc470a9c758ff35ed5cff69077423a629566082a605a01d8207d57cd6c",
       "Source": "/var/lib/docker/volumes/821b0abc470a9c758ff35ed5cff69077423a629566082a605a01d8207d57cd6c/_data",
       "Destination": "/prometheus",
       "Driver": "local",
       "Mode": "",
       "RW": true
   }
],
...

In diesem Beispiel werden die Metriken in "+ / var / lib / docker / volume / 821b0abc470a9c758ff35ed5cff69077423a629566082a605a01d8207d57cd6c / _data " auf dem Hostsystem gespeichert. Dieses Verzeichnis wurde von Docker beim ersten Start des Prometheus-Containers automatisch erstellt. Es wird in das Verzeichnis " / prometheus +" im Container abgebildet. Die Daten in diesem Verzeichnis bleiben auch nach einem Neustart desselben Containers erhalten. Wenn Sie möchten, können Sie auch ein vorhandenes Hostverzeichnis zum Speichern von Metrikdaten bereitstellen. Informationen dazu finden Sie unter How To Work with Docker Data Volumes unter Ubuntu 14.04 um das zu erreichen.

Sie sollten jetzt in der Lage sein, Ihren Prometheus-Server unter + http: //: 9090 / + zu erreichen. Stellen Sie sicher, dass Metriken über sich selbst erfasst werden, indem Sie auf "+ http: //: 9090 / status " gehen und den " http: // localhost: 9090 / metrics " - Endpunkt für den " prometheus " - Job in den "Targets" suchen. Sektion. Die Spalte * Status * für dieses Ziel sollte den Status des Ziels als * GESUND * anzeigen. Im Gegensatz dazu sollte der Endpunkt ` http: // localhost: 9100 / metrics +` (Node Exporter) weiterhin als * UNHEALTHY * angezeigt werden, da der Node Exporter noch nicht gestartet wurde und daher nicht gelöscht werden kann:

image: https: //assets.digitalocean.com/articles/prometheus_install_docker/unhealthy.png [Das Node Exporter-Ziel sollte als UNHEALTHY angezeigt werden.]

Zusammenfassend lässt sich sagen, dass Prometheus jetzt als Docker-Container mit der benutzerdefinierten Prometheus-Konfigurationsdatei "+ ~ / prometheus.yml " ausgeführt wird, die sich auf dem Host-Dateisystem befindet. Der Metrikspeicher befindet sich im Verzeichnis " / prometheus " des Containers, der auf dem Hostsystem durch den Pfad gesichert ist, der durch den in diesem Abschnitt erläuterten Befehl " docker inspect +" angegeben wird.

Schritt 2 - Einrichten von Node Exporter

In diesem Abschnitt installieren wir den Prometheus Node Exporter. Der Node Exporter ist ein Server, der Prometheus-Messdaten zu dem Host-Computer (Knoten) bereitstellt, auf dem er ausgeführt wird. Dies umfasst Metriken zu Dateisystemen, Netzwerkgeräten, Prozessorauslastung, Speicherauslastung usw. des Computers.

Beachten Sie, dass das Ausführen des Node Exporter in Docker einige Herausforderungen mit sich bringt, da der gesamte Zweck darin besteht, Messdaten über den Host bereitzustellen, auf dem er ausgeführt wird. Wenn Sie es ohne weitere Optionen auf Docker ausführen, werden durch den Namensraum von Docker für Ressourcen wie das Dateisystem und die Netzwerkgeräte nur Messdaten über die Containerumgebung exportiert, die sich von der Hostumgebung unterscheiden. Daher wird normalerweise empfohlen, den Node Exporter direkt auf dem Host-System außerhalb von Docker auszuführen. Wenn Sie jedoch alle Prozesse mit Docker verwalten müssen, beschreiben wir eine Problemumgehung, die eine sinnvolle Annäherung für den Export von Hostmetriken aus Docker bietet.

So starten Sie den Node Exporter über Docker an Port 9100:

docker run -d -p 9100:9100 -v "/proc:/host/proc" -v "/sys:/host/sys" -v "/:/rootfs" --net="host" prom/node-exporter -collector.procfs /host/proc -collector.sysfs /host/proc -collector.filesystem.ignored-mount-points "^/(sys|proc|dev|host|etc)($|/)"

Die folgenden Docker- und Node-Exporter-Flags werden verwendet, um eine angemessene Annäherung für die host-Metriken bereitzustellen:

  • Unter Linux sammelt der Node Exporter die meisten seiner Metriken aus den Dateisystemen "+ / proc " und " / sys ". Diese Dateisysteme werden vom Host unter Verwendung des Docker-Flags " -v " in den Container unter einem " / host +" -Verzeichnis eingebunden.

  • Über die Flags "+ -collector.procfs " und " -collector.sysfs " des Node Exporters weisen wir den Node Exporter an, nach den Dateisystemen " / proc " und " / sys +" an einem nicht standardmäßigen Speicherort zu suchen.

  • Um Metriken des Host-Dateisystems zu melden, mounten wir auch das gesamte Root-Dateisystem ("+ / ") in den Container (unter " / rootfs "), ebenfalls unter Verwendung des Docker-Flags " -v +".

  • Verwenden Sie das + -collector.filesystem.ignored-mount-points + -Flag des Node Exporters, um alle anderen Dateisysteme im Container zu ignorieren, die nicht zum Hostsystem gehören. Diese Option verwendet einen regulären Ausdruck von Einhängepunkten, um von den gemeldeten Metriken auszuschließen.

  • Mit dem Docker-Flag "+ - net = host " platzieren wir den Container im selben Netzwerkstapel wie den Host, sodass das Lesen von Dateien wie " / proc / net / dev " zu den gleichen Ergebnissen wie auf dem führt Host (Lesen aus dem vom Host eingehängten ` / proc +` - Dateisystem ist nicht ausreichend).

Beachten Sie, dass sich einige Metriken im Vergleich zu einem Node Exporter, der direkt auf dem Host ausgeführt wird, noch unterscheiden. Insbesondere haben Metriken, die über die Verwendung des Dateisystems gemeldet werden, ein Präfix "+ / rootfs " im Wert ihrer " mountpoint +" - Bezeichnungen, da wir sie im Root-Dateisystem unter diesem Präfix im Container einhängen. Es gibt auch keine Garantie dafür, dass die beschriebenen Problemumgehungen für zukünftige Node Exporter-Funktionen ausreichen. Führen Sie Node Exporter daher nach eigenem Ermessen in Docker aus.

Der Prometheus-Server sollte nun automatisch mit dem Scraping des Node Exporter beginnen. Gehen Sie zur Statusseite Ihres Prometheus-Servers unter "+ http: //: 9090 / status " und überprüfen Sie, ob das " http: //: 9100 / metrics " -Ziel für den " node +" - Job jetzt den Status "GESUND" anzeigt :

image: https: //assets.digitalocean.com/articles/prometheus_install_docker/healthy.png [Das Node Exporter-Ziel sollte als GESUND angezeigt werden.]

Schritt 3 - Grafana einrichten

Schließlich werden wir Grafana einrichten. Grafana ist ein grafischer Dashboard-Builder, der Prometheus als Backend für die Abfrage von Daten für Diagramme unterstützt.

Grafana speichert seine Dashboard-Metadaten (z. B. welche Dashboards vorhanden sind und welche Diagramme sie anzeigen sollen) in einer konfigurierbaren SQL-basierten Datenbank. Grafana unterstützt hierfür die Verwendung einer lokalen dateibasierten SQLite3-Datenbank sowie externer Datenbankserver wie MySQL oder PostgreSQL.

In diesem Tutorial verwenden wir eine SQLite3-Datenbank, die von einem Docker-Daten-Volume unterstützt wird. Weitere Informationen finden Sie unter How and When to Use Sqlite.

Starten Sie Grafana als Docker-Container mit einem Administratorkennwort (++) Ihrer Wahl:

docker run -d -p 3000:3000 -e "GF_SECURITY_ADMIN_PASSWORD=" -v ~/grafana_db:/var/lib/grafana grafana/grafana

Dadurch wird das Grafana Docker-Image vom Docker Hub heruntergeladen und ein neues Docker-Volume erstellt, das auf dem Hostsystem unter "+ ~ / grafana_db " und im Containerdateisystem unter " / var / lib / grafana " abgelegt wird. Im Container erstellt und initialisiert Grafana dann automatisch seine SQLite3-Datenbank unter ` / var / lib / grafana / grafana.db +`.

Das Flag "+ -e " ermöglicht die Übergabe von Umgebungsvariablen an den im Docker-Container gestarteten Prozess. In diesem Fall setzen wir die Umgebungsvariable " GF_SECURITY_ADMIN_PASSWORD " auf das gewünschte Dashboard-Administratorkennwort und überschreiben das Standardkennwort " admin +". Umgebungsvariablen können auch verwendet werden, um andere Grafana-Konfigurationseinstellungen zu überschreiben. Weitere Informationen finden Sie unter Using environment variables.

Um zu überprüfen, ob Grafana korrekt ausgeführt wird, gehen Sie zu "+ http: //: 3000 / ". Der Administrator-Benutzername lautet " admin" und das Passwort ist dasjenige, das Sie beim vorherigen Starten des Docker-Containers ausgewählt haben.

image: https://assets.digitalocean.com/articles/prometheus_install_docker/grafana_login.png [Melden Sie sich bei Grafana mit dem von Ihnen gewählten Passwort an.]

Nach dem Anmelden sollte die Hauptansicht von Grafana angezeigt werden:

image: https://assets.digitalocean.com/articles/prometheus_install_docker/grafana_main.png [Grafana-Hauptansicht]

Weitere Informationen zu den ersten Schritten mit Grafana finden Sie unter Grafana documentation. Die Prometheus Grafana documentation zeigt auch, wie Grafana speziell in Kombination mit Prometheus verwendet wird.

Fazit

Herzliche Glückwünsche! Sie haben einen Prometheus-Server, einen Node-Exporter und Grafana eingerichtet - alle mit Docker. Obwohl diese derzeit alle auf demselben Computer ausgeführt werden, dient dies nur zu Demonstrationszwecken. In Produktionsumgebungen wird normalerweise der Node Exporter auf jedem überwachten Computer, mehreren Prometheus-Servern (je nach Bedarf des Unternehmens) sowie einem einzelnen Grafana-Server ausgeführt, um die Daten von diesen Servern grafisch darzustellen.

Weitere Informationen zur allgemeinen Verwendung von Prometheus finden Sie unter documentation.

Related