Prometheus-Überwachungssystem

Mit zunehmender Komplexität von Systemen und Anwendungen wird die Überwachung unerlässlich, um optimale Leistung, Zuverlässigkeit und Skalierbarkeit zu gewährleisten. Prometheus, ein Open-Source-Überwachungs- und Alarmierungs-Toolkit, hat sich zu einer der beliebtesten Lösungen für die Verwaltung und Visualisierung von Metriken aus verschiedenen Systemen entwickelt. Ursprünglich von SoundCloud entwickelt, ist Prometheus heute ein Projekt der Cloud Native Computing Foundation (CNCF) und wird branchenübergreifend eingesetzt.

In diesem Artikel werden wir die wichtigsten Funktionen von Prometheus, seine Funktionsweise und die erforderlichen Schritte zur Einrichtung für die Überwachung Ihrer Infrastruktur und Anwendungen untersuchen.

Was ist Prometheus?

Prometheus ist ein leistungsstarkes Überwachungssystem zum Erfassen, Speichern und Abfragen von Zeitreihendaten, d. h. von Messungen oder Ereignissen, die im Laufe der Zeit verfolgt werden. Die von Prometheus gesammelten Daten können visualisiert, analysiert und zum Auslösen von Warnungen verwendet werden, damit Teams den Zustand und die Leistung ihrer Infrastruktur im Blick behalten.

Prometheus ist für mehrere wichtige Funktionen bekannt:

• Zeitreihen-Datenmodell: Prometheus speichert Daten als Zeitreihen, d. h. Metriken werden über Zeitintervalle aufgezeichnet.
• Pull-basierte Überwachung: Anstatt dass die überwachten Systeme Metriken an den Server senden, verwendet Prometheus ein Pull-basiertes Modell, um Metriken von Endpunkten abzurufen.
• Leistungsstarke Abfragesprache (PromQL): Prometheus bietet eine leistungsstarke Abfragesprache, PromQL, mit der Benutzer Metriken in Echtzeit filtern und aggregieren können.
• Alarmierung: Prometheus ist mit dem Alertmanager integriert, um Regeln zu definieren und Benachrichtigungen zu senden, wenn bestimmte Bedingungen erfüllt sind.
• Dienst-Entdeckung: Prometheus kann automatisch Metriken aus sich dynamisch verändernden Umgebungen wie Kubernetes erkennen und abrufen.

Wie Prometheus funktioniert

Prometheus folgt einer einfachen, aber robusten Architektur, die für die Überwachung von Zeitseriendaten entwickelt wurde. So funktioniert es:

1. Metrik-Sammlung (Scraping): Prometheus sammelt in regelmäßigen Abständen Metriken von HTTP-Endpunkten (als Exporter bezeichnet), die von Anwendungen oder Systemen bereitgestellt werden.
2. Speicherung von Zeitreihendaten: Nach der Erfassung speichert Prometheus die Metriken in einer Zeitreihendatenbank, in der jeder Datenpunkt mit einem Zeitstempel und einer Reihe von Bezeichnungen versehen ist.
3. Abfragen mit PromQL: Benutzer können die gespeicherten Metriken mit der Prometheus-Abfragesprache PromQL abfragen, um Diagramme, Dashboards oder Warnmeldungen zu erstellen.
4. Alarmierung: Basierend auf vordefinierten Bedingungen kann Prometheus mithilfe des Alertmanagers Alarme auslösen, die Benachrichtigungen per E-Mail, Slack, PagerDuty oder andere Dienste senden können.

Prometheus unterstützt ein Pull-basiertes Modell, bei dem es regelmäßig Metriken von Endpunkten abruft, die Metriken in einem Format bereitstellen, das Prometheus versteht. Dies macht es ideal für die Überwachung von verteilten Systemen und Microservices, wo Skalierung und dynamische Umgebungen üblich sind.

Prometheus-Komponenten

Prometheus besteht aus mehreren Kernkomponenten, die jeweils einen anderen Zweck erfüllen:

1. Prometheus-Server: Die zentrale Komponente, die für das Sammeln, Speichern und Abfragen von Metriken zuständig ist. Sie sammelt die Zielendpunkte und speichert die Metriken in einer Zeitseriendatenbank.
2. Exporteure: Dies sind Anwendungen oder Dienste, die Metriken in einem Prometheus-kompatiblen Format bereitstellen. Übliche Exporteure sind:
   • Node Exporter: Sammelt Metriken auf Hardware- und Betriebssystemebene.
   • Blackbox Exporter: Zur Überprüfung von Endpunkten über HTTP, DNS, TCP usw.
   • Anwendungsspezifische Exporter: Viele Datenbanken (wie PostgreSQL, MySQL) und Dienste haben ihre eigenen Exporter.
3. Alertmanager: Prometheus verwendet den Alertmanager zur Verwaltung von Alarmen. Er kann Alarme an verschiedene Empfänger wie Slack, E-Mail oder SMS weiterleiten und Silencing- und Inhibitionsregeln verwalten.
4. PromQL (Prometheus-Abfragesprache): Eine leistungsstarke Abfragesprache zum Abrufen und Verarbeiten von Zeitreihendaten.
5. Pushgateway: Eine Komponente für ephemere oder kurzlebige Jobs, die keine Metriken über einen direkten Scrape (z. B. Batch-Jobs) bereitstellen können. Das Pushgateway ermöglicht es diesen Jobs, ihre Metriken an Prometheus zu senden.
6. Grafana: Obwohl nicht Teil von Prometheus selbst, ist Grafana ein beliebtes Open-Source-Tool, das zur Visualisierung von Prometheus-Daten und zur Erstellung interaktiver Dashboards verwendet wird.

Schritt-für-Schritt-Einrichtung von Prometheus

Im Folgenden wird beschrieben, wie Sie Prometheus auf einem Linux-Server einrichten und mit der Überwachung von Systemmetriken beginnen können:

Schritt 1: Prometheus installieren

1. Laden Sie Prometheus herunter: Besuchen Sie die Prometheus-Downloadseite, um die neueste Version von Prometheus herunterzuladen, und führen Sie die folgenden Befehle aus, um Prometheus herunterzuladen und zu entpacken:
   wget https://github.com/prometheus/prometheus/releases/download/v2.32.1/prometheus-2.32.1.linux-amd64.tar.gz tar -xvf prometheus-2.32.1.linux-amd64.tar.gz cd prometheus-2.32.1.linux-amd64
2. Starten Sie Prometheus: Führen Sie den folgenden Befehl aus, um Prometheus zu starten:
   ./prometheus –config.file=prometheus.yml

   Standardmäßig wird Prometheus auf Port 9090 ausgeführt, und Sie können auf seine Weboberfläche zugreifen, indem Sie in Ihrem Browser zu http://localhost:9090 navigieren.

Schritt 2: Konfigurieren Sie Prometheus

Die Hauptkonfiguration für Prometheus wird über die Datei prometheus.yml vorgenommen. Diese Datei teilt Prometheus mit, welche Ziele (Exporteure) wie oft abgefragt werden sollen.

Hier ist eine grundlegende prometheus.yml-Konfiguration:

Sie können bei Bedarf weitere Ziele oder Exporteure hinzufügen, und Prometheus beginnt automatisch mit dem Scrapen dieser.

Schritt 3: Installieren Sie den Node Exporter (für Systemmetriken)

Um Systemmetriken wie CPU-, Speicher-, Festplatten- und Netzwerknutzung zu überwachen, können Sie den Node Exporter installieren.

1. Laden Sie Node Exporter herunter:
   wget https://github.com/prometheus/node_exporter/releases/download/v1.3.1/node_exporter-1.3.1.linux-amd64.tar.gz tar -xvf node_exporter-1.3.1.linux-amd64.tar.gz cd node_exporter-1.3.1.linux-amd64
2. Starten Sie Node Exporter: Führen Sie den folgenden Befehl aus, um Node Exporter zu starten:
   ./node_exporter

   Standardmäßig läuft Node Exporter auf Port 9100 und zeigt Metriken wie CPU-Nutzung, Speicherstatistiken, Festplatten-E/A und Netzwerkmetriken an.

3. Konfigurieren Sie Prometheus für das Scrapen von Node Exporter: Fügen Sie den folgenden Job zur Konfigurationsdatei prometheus.yml hinzu:
   scrape_configs: – job_name: ‘node_exporter’ static_configs: – targets: [‘localhost:9100’]
4. Starten Sie Prometheus neu: Nachdem Sie Änderungen an der Konfigurationsdatei vorgenommen haben, starten Sie Prometheus neu, um mit dem Scrapen von Metriken von Node Exporter zu beginnen.

Schritt 4: Visualisieren von Metriken mit Grafana

Um Prometheus-Metriken zu visualisieren, ist Grafana ein hervorragendes Tool. Es lässt sich nahtlos in Prometheus integrieren und ermöglicht es Ihnen, interaktive Dashboards zu erstellen.

1. Grafana installieren: Unter Linux können Sie Grafana installieren, indem Sie den Anweisungen auf der Grafana-Website folgen.
2. Konfigurieren Sie Prometheus als Datenquelle: Nach der Installation von Grafana:
   • Melden Sie sich bei Grafana an (http://localhost:3000).
   • Gehen Sie zu Configuration > Data Sources und fügen Sie Prometheus als Datenquelle hinzu (http://localhost:9090).
3. Dashboards erstellen: Jetzt können Sie Ihre eigenen Dashboards erstellen oder vorgefertigte Dashboards aus dem Grafana-Marktplatz importieren, um Metriken wie CPU-Nutzung, Speichernutzung, Festplattenleistung und mehr zu visualisieren.

Schritt 5: Alerts einrichten

Prometheus ermöglicht Ihnen die Konfiguration von Alarmen, die auf bestimmten Bedingungen basieren, wie z. B. hohe CPU-Auslastung, geringer Speicherplatz oder Anwendungsausfälle.

1. Definieren Sie Alerting-Regeln: Alarme werden in einer separaten rules.yml-Datei definiert. Hier ein Beispiel für eine Warnregel, die ausgelöst wird, wenn die CPU-Auslastung mehr als 80 % beträgt:
   groups: – name: example_alerts rules: – alert: HighCPUUsage expr: 100 – (avg by(instance) (rate(node_cpu_seconds_total{mode=”idle”}[5m])) * 100) > 80 for: 5m labels: severity: warning annotations: summary: “High CPU usage detected on {{ $labels.instance }}” description: “Die CPU-Auslastung liegt seit mehr als 5 Minuten über 80%.”
2. Konfigurieren Sie den Alertmanager: Installieren und konfigurieren Sie den Alertmanager, um Benachrichtigungen per E-Mail, Slack oder über andere Kanäle zu senden, wenn ein Alert ausgelöst wird.

Anwendungsfälle für Prometheus

Prometheus wird in einer Vielzahl von Szenarien verwendet, um verschiedene Arten von Systemen zu überwachen, darunter:

1. Infrastruktur-Überwachung: Erfassen Sie Metriken von Servern, Datenbanken und Netzwerkgeräten, um sicherzustellen, dass Ihre Infrastruktur reibungslos funktioniert.
2. Anwendungsüberwachung: Verfolgen Sie Leistungsmetriken wie Latenz, Anforderungsrate, Fehlerraten und Ressourcenverbrauch von Anwendungen, insbesondere in Microservice-Architekturen.
3. Kubernetes-Überwachung: Prometheus lässt sich nativ in Kubernetes integrieren und kann automatisch Metriken von Pods und Diensten in einem Kubernetes-Cluster erkennen und abrufen.
4. Benutzerdefinierte Metriken: Prometheus ermöglicht es Ihnen, Ihre eigenen Anwendungen zu instrumentieren, um benutzerdefinierte Metriken aufzudecken, die tiefe Einblicke in anwendungsspezifische Verhaltensweisen bieten.

Fazit

Prometheus ist eine leistungsstarke und flexible Überwachungslösung, die die Sammlung, Abfrage und Alarmierung auf der Grundlage von Zeitreihendaten in Echtzeit ermöglicht. Ganz gleich, ob Sie Metriken auf Systemebene oder die Anwendungsleistung in einer Microservices-Architektur überwachen, Prometheus ist ein wertvolles Tool, um den Zustand und die Stabilität Ihrer Infrastruktur sicherzustellen.

Wenn Sie die in diesem Artikel beschriebenen Schritte befolgen, können Sie mit Prometheus beginnen, Metriken von Ihren Systemen sammeln und diese Metriken mit Grafana visualisieren. Im Laufe der Zeit kann Prometheus Ihnen helfen, Einblicke in Leistungstrends zu gewinnen, Anomalien zu erkennen und schnell auf Vorfälle zu reagieren, um sowohl die Systembetriebszeit als auch die Zuverlässigkeit zu verbessern.