21 Daten sammeln

21.1 Metriken und Zeitreihen

Prometheus sammelt und speichert Daten in Form von Metriken und Zeitreihen. Das Verständnis dieser grundlegenden Konzepte ist entscheidend, um die Funktionsweise von Prometheus und die Erstellung effizienter Abfragen zu verstehen.

21.1.1 Metriken

Metriken sind die grundlegenden Datenpunkte, die Prometheus sammelt und speichert. Jede Metrik hat einen Namen und kann eine oder mehrere Labels besitzen, die zusätzliche Informationen zur Metrik liefern.

1. Metriktypen:
   • Counter: Zählt nur nach oben und wird verwendet, um kumulative Werte wie Anfragen oder Fehler zu messen. Beispiel: http_requests_total
   • Gauge: Kann sowohl nach oben als auch nach unten zählen und misst aktuelle Werte wie CPU-Auslastung oder Speichernutzung. Beispiel: node_memory_MemAvailable_bytes
   • Histogram: Misst die Verteilung von Werten über vorgegebene Buckets und wird verwendet, um z.B. Antwortzeiten zu messen. Beispiel: http_request_duration_seconds
   • Summary: Ähnlich wie Histogram, aber bietet zusätzlich Quantile an, um z.B. die 95. Perzentil-Antwortzeit zu messen. Beispiel: http_request_duration_seconds_summary
2. Labels:
   • Labels sind Schlüssel-Wert-Paare, die zusätzliche Dimensionen zu einer Metrik hinzufügen. Sie ermöglichen die detaillierte Segmentierung und Filterung von Metriken.
   • Beispiel: http_requests_total{method="GET", handler="/api"}

21.1.2 Zeitreihen

Eine Zeitreihe ist eine Sequenz von Metrikwerten, die zu bestimmten Zeitpunkten gesammelt werden. Jede Zeitreihe ist durch einen Metriknamen und eine einzigartige Kombination von Labels definiert.

1. Beispiel einer Zeitreihe:

   • Metrik: http_requests_total

   • Labels: {method="GET", handler="/api"}

   • Zeitpunkte und Werte:

     timestamp: 1625247600, value: 100
     timestamp: 1625247660, value: 150
     timestamp: 1625247720, value: 200

2. Storage und Abfrage:
   • Zeitreihen werden in der Prometheus-Zeitreihendatenbank (TSDB) gespeichert. Sie können mit PromQL abgefragt werden, einer leistungsstarken Abfragesprache, die speziell für die Arbeit mit Zeitreihen entwickelt wurde.

21.1.3 Abfragen mit PromQL

PromQL (Prometheus Query Language) ist die Abfragesprache von Prometheus, die speziell für die Arbeit mit Metriken und Zeitreihen entwickelt wurde. Hier sind einige grundlegende Abfragen und Beispiele.

1. Grundlegende Abfrage:
   • Abfrage: http_requests_total
   • Beschreibung: Gibt die aktuelle Anzahl der HTTP-Anfragen zurück.
2. Abfrage mit Label-Filter:
   • Abfrage: http_requests_total{method="GET"}
   • Beschreibung: Gibt die Anzahl der HTTP GET-Anfragen zurück.
3. Rate-Abfrage:
   • Abfrage: rate(http_requests_total[5m])
   • Beschreibung: Gibt die Rate der HTTP-Anfragen pro Sekunde über die letzten 5 Minuten zurück.
4. Summenbildung:
   • Abfrage: sum(rate(http_requests_total[5m])) by (method)
   • Beschreibung: Gibt die Rate der HTTP-Anfragen pro Sekunde, gruppiert nach HTTP-Methode, zurück.
5. Histogram-Abfrage:
   • Abfrage: histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le))
   • Beschreibung: Gibt die 95. Perzentil-Antwortzeit der HTTP-Anfragen über die letzten 5 Minuten zurück.

21.1.4 Metriken sammeln

Prometheus verwendet das Pull-Modell, um Metriken zu sammeln. Dies bedeutet, dass Prometheus in regelmäßigen Abständen HTTP-Anfragen an die definierten Endpunkte sendet, um Metriken abzurufen.

1. Scraping:

   • In der prometheus.yml-Datei werden Scrape-Jobs definiert, die festlegen, welche Endpunkte wie oft abgefragt werden sollen.

   • Beispiel:

     scrape_configs:
       - job_name: 'node_exporter'
         static_configs:
           - targets: ['localhost:9100']

2. Exporter:
   • Exporter sind spezielle Anwendungen, die Metriken von verschiedenen Systemen und Anwendungen sammeln und in einem Prometheus-kompatiblen Format bereitstellen.
   • Beispiel: node_exporter für Systemmetriken, blackbox_exporter für Endpunkt-Verfügbarkeit, mysql_exporter für MySQL-Datenbankmetriken.

21.1.5 Aufzeichnungs- und Alarmierungsregeln

Prometheus unterstützt die Definition von Aufzeichnungsregeln (Recording Rules) und Alarmierungsregeln (Alerting Rules), um komplexe Abfragen zu vereinfachen und Alarme auszulösen.

1. Aufzeichnungsregeln:

   • Dienen zur Vorab-Berechnung komplexer Abfragen und zur Speicherung der Ergebnisse als neue Metriken.

   • Beispiel:

     groups:
       - name: example
         rules:
           - record: job:http_inprogress_requests:sum
             expr: sum by (job) (http_inprogress_requests)

2. Alarmierungsregeln:

   • Dienen zur Definition von Bedingungen, unter denen Alarme ausgelöst werden.

   • Beispiel:

     groups:
       - name: example-alerts
         rules:
           - alert: InstanceDown
             expr: up == 0
             for: 5m
             labels:
               severity: critical
             annotations:
               summary: "Instance {{ $labels.instance }} down"
               description: "{{ $labels.instance }} of job {{ $labels.job }} has been down for more than 5 minutes."

Durch das Verständnis der Konzepte von Metriken und Zeitreihen und die effektive Nutzung von PromQL können Sie leistungsstarke Überwachungs- und Alarmierungslösungen mit Prometheus implementieren.

21.2 Data Scraping und Job-Konfiguration

Das Data Scraping und die Konfiguration von Jobs sind zentrale Elemente in Prometheus, um Daten von verschiedenen Endpunkten zu sammeln. Diese Konfiguration wird in der prometheus.yml-Datei vorgenommen und bestimmt, welche Metriken wie oft gesammelt werden.

21.2.1 Grundlegende Struktur der prometheus.yml

Die prometheus.yml-Datei enthält verschiedene Abschnitte, um die globale Konfiguration, das Scraping und die Regeln zu definieren. Der wichtigste Abschnitt für das Data Scraping ist scrape_configs.

21.2.2 Beispielhafte prometheus.yml

global:
  scrape_interval: 15s   # Wie oft Metriken gesammelt werden
  evaluation_interval: 15s # Wie oft Regeln ausgewertet werden

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

21.2.3 Konfiguration von Scrape-Jobs

Ein Scrape-Job definiert, welche Endpunkte Prometheus abfragt und wie diese Abfragen konfiguriert sind. Jeder Job hat mehrere Parameter, die die Konfiguration steuern.

1. job_name:

   • Ein eindeutiger Name für den Scrape-Job.

   • Beispiel:

     job_name: 'node_exporter'

2. static_configs:

   • Statische Konfiguration von Targets. Hier werden die festen Endpunkte definiert, die Prometheus abfragt.

   • Beispiel:

     static_configs:
       - targets: ['localhost:9100']

3. Scrape-Intervall:

   • Das Intervall, in dem Prometheus die Metriken von den Targets sammelt. Dies kann global oder pro Job definiert werden.

   • Beispiel:

     scrape_interval: 30s

4. HTTP-Parameter:

   • HTTP-spezifische Parameter wie der Pfad, den Prometheus abfragt.

   • Beispiel:

     metrics_path: /metrics

5. Basic Authentication:

   • Konfiguration von Benutzername und Passwort für die Authentifizierung.

   • Beispiel:

     basic_auth:
       username: 'user'
       password: 'password'

21.2.3.1 Beispiele für verschiedene Scrape-Jobs

1. Node Exporter:

   • Ein Scrape-Job zur Überwachung von Systemmetriken mit dem node_exporter.

   • Beispiel:

     scrape_configs:
       - job_name: 'node_exporter'
         static_configs:
           - targets: ['localhost:9100']

2. Blackbox Exporter:

   • Ein Scrape-Job zur Überwachung der Verfügbarkeit und Antwortzeiten von Endpunkten mit dem blackbox_exporter.

   • Beispiel:

     scrape_configs:
       - job_name: 'blackbox'
         metrics_path: /probe
         params:
           module: [http_2xx]
         static_configs:
           - targets:
             - http://example.com
         relabel_configs:
           - source_labels: [__address__]
             target_label: __param_target
           - source_labels: [__param_target]
             target_label: instance
           - target_label: __address__
             replacement: 127.0.0.1:9115

3. MySQL Exporter:

   • Ein Scrape-Job zur Überwachung von MySQL-Datenbanken mit dem mysql_exporter.

   • Beispiel:

     scrape_configs:
       - job_name: 'mysql_exporter'
         static_configs:
           - targets: ['localhost:9104']

21.2.4 Service Discovery

In dynamischen Umgebungen wie Kubernetes kann Prometheus automatisch neue Targets entdecken und überwachen. Dies geschieht durch Service Discovery Mechanismen.

1. Kubernetes Service Discovery:

   • Beispielkonfiguration für die automatische Erkennung von Pods in einem Kubernetes-Cluster.

     scrape_configs:
       - job_name: 'kubernetes-pods'
         kubernetes_sd_configs:
           - role: pod
         relabel_configs:
           - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
             action: keep
             regex: true
           - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
             action: replace
             target_label: __metrics_path__
             regex: (.+)
           - source_labels: [__address__]
             action: replace
             target_label: __address__
             regex: (.+):\d+
             replacement: $1:8080

2. Consul Service Discovery:

   • Beispielkonfiguration für die automatische Erkennung von Services in einem Consul-Cluster.

     scrape_configs:
       - job_name: 'consul'
         consul_sd_configs:
           - server: 'localhost:8500'
         relabel_configs:
           - source_labels: [__meta_consul_service]
             action: replace
             target_label: job

21.2.5 Relabeling

Relabeling ist ein wichtiger Prozess in Prometheus, um Labels von Metriken zu modifizieren, bevor sie gespeichert werden. Dies ist besonders nützlich, um dynamische Umgebungen zu handhaben oder spezifische Labels hinzuzufügen bzw. zu ändern.

1. Beispiel für Relabeling-Konfiguration:

   • Ersetzen des Labels __address__ durch das Label instance.

     scrape_configs:
       - job_name: 'example'
         static_configs:
           - targets: ['localhost:9100']
         relabel_configs:
           - source_labels: [__address__]
             target_label: instance
             regex: (.*):\d+
             replacement: $1

21.2.6 Best Practices

1. Regelmäßige Überprüfung und Aktualisierung der Konfiguration:
   • Stellen Sie sicher, dass die prometheus.yml regelmäßig überprüft und aktualisiert wird, um neue Targets und Änderungen in der Infrastruktur abzubilden.
2. Minimierung des Overheads:
   • Überwachen Sie nur die notwendigen Metriken und Targets, um den Overhead und die Belastung auf Prometheus und die überwachten Systeme zu minimieren.
3. Sicherheit:
   • Schützen Sie Ihre Targets und Prometheus-Instanzen durch geeignete Sicherheitsmaßnahmen wie Authentifizierung, Verschlüsselung und Zugriffskontrollen.

Durch die sorgfältige Konfiguration von Scrape-Jobs und die effektive Nutzung von Service Discovery Mechanismen können Sie sicherstellen, dass Prometheus zuverlässig und effizient die benötigten Metriken sammelt und überwacht.

21.2.7 Nutzung von Exportern

Exporter sind spezielle Anwendungen, die Metriken von verschiedenen Systemen und Anwendungen sammeln und in einem Prometheus-kompatiblen Format bereitstellen. Sie sind ein wesentlicher Bestandteil der Prometheus-Architektur und ermöglichen die Überwachung einer Vielzahl von Systemen, Diensten und Anwendungen.

21.2.7.1 Was ist ein Exporter?

Ein Exporter sammelt Metriken von einem bestimmten System oder einer Anwendung und stellt sie im Prometheus-Format unter einem bestimmten HTTP-Endpunkt zur Verfügung. Prometheus kann dann diese Metriken durch regelmäßige Scraping-Vorgänge sammeln.

21.2.7.2 Wichtige Exporter und ihre Anwendungsfälle

1. node_exporter

   • Beschreibung: Überwacht Systemmetriken wie CPU-Auslastung, Speicherverbrauch, Netzwerktraffic und Dateisystemnutzung.

   • Anwendungsfall: Überwachung der Gesundheit und Leistung von Servern und Workstations.

   • Installation: Offizielle node_exporter Dokumentation

   • Konfiguration in Prometheus:

     scrape_configs:
       - job_name: 'node_exporter'
         static_configs:
           - targets: ['localhost:9100']

2. blackbox_exporter

   • Beschreibung: Ermöglicht die Überwachung der Verfügbarkeit und Antwortzeiten von HTTP, HTTPS, DNS, TCP und ICMP.

   • Anwendungsfall: Überwachung der Erreichbarkeit von Diensten und Endpunkten.

   • Installation: Offizielle blackbox_exporter Dokumentation

   • Konfiguration in Prometheus:

     scrape_configs:
       - job_name: 'blackbox'
         metrics_path: /probe
         params:
           module: [http_2xx]
         static_configs:
           - targets:
             - http://example.com
         relabel_configs:
           - source_labels: [__address__]
             target_label: __param_target
           - source_labels: [__param_target]
             target_label: instance
           - target_label: __address__
             replacement: 127.0.0.1:9115

3. mysql_exporter

   • Beschreibung: Überwacht Metriken von MySQL-Datenbanken wie Verbindungen, Abfragen, Cache-Hits und Speicherverbrauch.

   • Anwendungsfall: Überwachung der Leistung und Verfügbarkeit von MySQL-Datenbanken.

   • Installation: Offizielle mysql_exporter Dokumentation

   • Konfiguration in Prometheus:

     scrape_configs:
       - job_name: 'mysql_exporter'
         static_configs:
           - targets: ['localhost:9104']

4. postgres_exporter

   • Beschreibung: Überwacht Metriken von PostgreSQL-Datenbanken wie Verbindungen, Abfragen, Transaktionen und Indexpflege.

   • Anwendungsfall: Überwachung der Leistung und Verfügbarkeit von PostgreSQL-Datenbanken.

   • Installation: Offizielle postgres_exporter Dokumentation

   • Konfiguration in Prometheus:

     scrape_configs:
       - job_name: 'postgres_exporter'
         static_configs:
           - targets: ['localhost:9187']

5. cadvisor

   • Beschreibung: Überwacht Container-Metriken wie CPU, Speicher, Netzwerk und Festplattennutzung für Docker-Container.

   • Anwendungsfall: Überwachung der Ressourcennutzung von Container-basierten Anwendungen.

   • Installation: Offizielle cadvisor Dokumentation

   • Konfiguration in Prometheus:

     scrape_configs:
       - job_name: 'cadvisor'
         static_configs:
           - targets: ['localhost:8080']

21.2.7.3 Installation und Konfiguration eines Exporters

1. Beispiel: Installation des node_exporter

   • Schritt 1: Download und Installation

     wget https://github.com/prometheus/node_exporter/releases/download/v1.2.2/node_exporter-1.2.2.linux-amd64.tar.gz
     tar xvfz node_exporter-1.2.2.linux-amd64.tar.gz
     sudo cp node_exporter-1.2.2.linux-amd64/node_exporter /usr/local/bin/

   • Schritt 2: Als Dienst einrichten Erstellen Sie eine Systemd-Dienstdatei unter /etc/systemd/system/node_exporter.service:

     [Unit]
     Description=Node Exporter
     Wants=network-online.target
     After=network-online.target
     
     [Service]
     User=nodeusr
     ExecStart=/usr/local/bin/node_exporter
     Restart=always
     
     [Install]
     WantedBy=multi-user.target

   • Schritt 3: Dienst starten und aktivieren

     sudo systemctl daemon-reload
     sudo systemctl start node_exporter
     sudo systemctl enable node_exporter

   • Schritt 4: Konfiguration in Prometheus Bearbeiten Sie die prometheus.yml-Datei und fügen Sie den node_exporter als Ziel hinzu:

     scrape_configs:
       - job_name: 'node_exporter'
         static_configs:
           - targets: ['localhost:9100']

2. Beispiel: Installation des blackbox_exporter

   • Schritt 1: Download und Installation

     wget https://github.com/prometheus/blackbox_exporter/releases/download/v0.18.0/blackbox_exporter-0.18.0.linux-amd64.tar.gz
     tar xvfz blackbox_exporter-0.18.0.linux-amd64.tar.gz
     sudo cp blackbox_exporter-0.18.0.linux-amd64/blackbox_exporter /usr/local/bin/

   • Schritt 2: Als Dienst einrichten Erstellen Sie eine Systemd-Dienstdatei unter /etc/systemd/system/blackbox_exporter.service:

     [Unit]
     Description=Blackbox Exporter
     Wants=network-online.target
     After=network-online.target
     
     [Service]
     User=blackboxusr
     ExecStart=/usr/local/bin/blackbox_exporter --config.file=/etc/blackbox_exporter/config.yml
     Restart=always
     
     [Install]
     WantedBy=multi-user.target

   • Schritt 3: Dienst starten und aktivieren

     sudo systemctl daemon-reload
     sudo systemctl start blackbox_exporter
     sudo systemctl enable blackbox_exporter

   • Schritt 4: Konfiguration in Prometheus Bearbeiten Sie die prometheus.yml-Datei und fügen Sie den blackbox_exporter als Ziel hinzu:

     scrape_configs:
       - job_name: 'blackbox'
         metrics_path: /probe
         params:
           module: [http_2xx]
         static_configs:
           - targets:
             - http://example.com
         relabel_configs:
           - source_labels: [__address__]
             target_label: __param_target
           - source_labels: [__param_target]
             target_label: instance
           - target_label: __address__
             replacement: 127.0.0.1:9115

21.2.7.4 Exporter spezifische Anpassungen

1. node_exporter:

   • Aktivieren/Deaktivieren von Sammlern

     /usr/local/bin/node_exporter --collector.cpu --collector.meminfo --no-collector.diskstats

2. blackbox_exporter:

   • Konfiguration von Modulen in config.yml

     modules:
       http_2xx:
         prober: http
         timeout: 5s
         http:
           valid_http_versions: [ "HTTP/1.1", "HTTP/2" ]
           method: GET
           fail_if_ssl: false

21.2.7.5 Best Practices für die Nutzung von Exportern

1. Zielgerichtete Überwachung:
   • Verwenden Sie nur die notwendigen Exporter, um die relevantesten Metriken zu sammeln und die Belastung des Netzwerks und der Systeme zu minimieren.
2. Sicherheit:
   • Stellen Sie sicher, dass die Exporter-Endpunkte sicher konfiguriert sind und nur von autorisierten Prometheus-Servern abgefragt werden können.
3. Ressourcenmanagement:
   • Überwachen Sie die Ressourcen, die von den Exportern selbst genutzt werden, um sicherzustellen, dass sie das überwachte System nicht übermäßig belasten.
4. Regelmäßige Updates:
   • Halten Sie die Exporter auf dem neuesten Stand, um von den neuesten Funktionen und Sicherheitsupdates zu profitieren.

Durch die effektive Nutzung von Exportern können Sie eine umfassende Überwachungsinfrastruktur aufbauen, die detaillierte Einblicke in die Leistung und Gesundheit Ihrer Systeme und Anwendungen bietet.

21.2.8 Best Practices

Um eine effiziente und effektive Überwachungsinfrastruktur mit Prometheus aufzubauen, ist es wichtig, einige bewährte Methoden zu beachten. Diese Best Practices helfen dabei, die Leistung und Zuverlässigkeit der Überwachung zu optimieren und gleichzeitig die Wartbarkeit und Skalierbarkeit des Systems sicherzustellen.

21.2.8.1 Planung und Architektur

1. Bedarfsanalyse:
   • Ermitteln Sie die Überwachungsanforderungen Ihrer Umgebung. Identifizieren Sie die kritischen Systeme, Anwendungen und Dienste, die überwacht werden müssen.
   • Bestimmen Sie die wichtigsten Metriken, die gesammelt und analysiert werden sollen.
2. Architekturplanung:
   • Entwerfen Sie eine skalierbare und hochverfügbare Architektur für Ihre Prometheus-Installation. Berücksichtigen Sie dabei die Anzahl der zu überwachenden Targets und das erwartete Datenvolumen.
   • Implementieren Sie redundante Prometheus-Server für Hochverfügbarkeit und Lastverteilung.
3. Datenaufbewahrung:
   • Planen Sie die Aufbewahrungszeit der gesammelten Metriken entsprechend den Anforderungen Ihrer Organisation.
   • Nutzen Sie externe Speicherlösungen oder Integrationen wie Thanos oder Cortex, um die Langzeitaufbewahrung und Skalierbarkeit zu verbessern.

21.2.8.2 Konfiguration und Verwaltung

1. Effiziente Scraping-Intervalle:

   • Setzen Sie die Scraping-Intervalle so, dass sie die Balance zwischen Aktualität der Daten und Systemressourcen finden.

   • Beispiel:

     global:
       scrape_interval: 30s
       evaluation_interval: 30s

2. Service Discovery:

   • Nutzen Sie Service Discovery Mechanismen, um dynamische Umgebungen wie Kubernetes effizient zu überwachen.

   • Beispiel:

     scrape_configs:
       - job_name: 'kubernetes-pods'
         kubernetes_sd_configs:
           - role: pod

3. Relabeling:

   • Verwenden Sie Relabeling, um Metrik-Labels zu normalisieren und unnötige Metriken zu filtern.

   • Beispiel:

     relabel_configs:
       - source_labels: [__meta_kubernetes_pod_label_app]
         target_label: app

4. Regelmäßige Konfigurationsüberprüfung:

   • Überprüfen und aktualisieren Sie regelmäßig die prometheus.yml-Datei, um neue Targets und Änderungen in der Infrastruktur abzubilden.

   • Beispiel:

     scrape_configs:
       - job_name: 'new_service'
         static_configs:
           - targets: ['new_service:9090']

21.2.8.3 Performance und Skalierbarkeit

1. Sharding und Federation:

   • Implementieren Sie Sharding und Föderation, um die Last auf mehrere Prometheus-Server zu verteilen.

   • Beispiel für Föderation:

     scrape_configs:
       - job_name: 'federation'
         honor_labels: true
         metrics_path: /federate
         params:
           'match[]':
             - '{job="prometheus"}'
         static_configs:
           - targets:
             - 'other-prometheus:9090'

2. Optimierung von PromQL-Abfragen:

   • Schreiben Sie effiziente PromQL-Abfragen, um die Abfragezeit und Systembelastung zu minimieren.

   • Beispiel:

     sum(rate(http_requests_total[5m])) by (job)

3. Aufzeichnungsregeln:

   • Verwenden Sie Aufzeichnungsregeln, um komplexe Abfragen vorab zu berechnen und die Ergebnisse als neue Metriken zu speichern.

   • Beispiel:

     groups:
       - name: example
         rules:
           - record: job:http_inprogress_requests:sum
             expr: sum by (job) (http_inprogress_requests)

21.2.8.4 Überwachung und Alarmierung

1. Definieren von Alarme:

   • Erstellen Sie Alarmierungsregeln, um auf Anomalien und kritische Zustände aufmerksam zu machen.

   • Beispiel:

     groups:
       - name: example-alerts
         rules:
           - alert: HighCPUUsage
             expr: sum(rate(node_cpu_seconds_total{mode="idle"}[5m])) by (instance) < 10
             for: 5m
             labels:
               severity: critical
             annotations:
               summary: "High CPU usage on {{ $labels.instance }}"
               description: "CPU usage is above 90% for more than 5 minutes."

2. Alertmanager-Integration:

   • Integrieren Sie den Alertmanager zur Verwaltung und Weiterleitung von Alarmen.

   • Beispiel:

     alerting:
       alertmanagers:
         - static_configs:
             - targets: ['localhost:9093']

3. Dashboarding und Visualisierung:

   • Verwenden Sie Grafana zur Erstellung von Dashboards, um Metriken visuell darzustellen und Trends zu analysieren.

   • Beispiel:

     {
       "dashboard": {
         "id": null,
         "title": "System Monitoring",
         "panels": [
           {
             "type": "graph",
             "title": "CPU Usage",
             "targets": [
               {
                 "expr": "100 - (avg by (instance, cpu) (rate(node_cpu_seconds_total{mode=\"idle\"}[5m])) * 100)",
                 "format": "time_series"
               }
             ]
           }
         ]
       }
     }

21.2.8.5 Sicherheit und Wartung

1. Zugriffskontrollen:

   • Implementieren Sie Zugriffskontrollen und Authentifizierung, um den Zugriff auf Prometheus und die Exporter-Endpunkte zu sichern.

   • Beispiel:

     basic_auth:
       username: 'user'
       password: 'password'

2. Verschlüsselung:

   • Nutzen Sie TLS/SSL, um die Kommunikation zwischen Prometheus, Exportern und dem Alertmanager zu sichern.

   • Beispiel:

     tls_config:
       ca_file: /etc/prometheus/certs/ca.crt
       cert_file: /etc/prometheus/certs/prometheus.crt
       key_file: /etc/prometheus/certs/prometheus.key

3. Regelmäßige Updates:
   • Halten Sie Prometheus und die verwendeten Exporter auf dem neuesten Stand, um von den neuesten Funktionen und Sicherheitsupdates zu profitieren.

Durch die Anwendung dieser Best Practices können Sie sicherstellen, dass Ihre Prometheus-basierte Überwachungsinfrastruktur effizient, skalierbar und zuverlässig ist. Dies hilft Ihnen, proaktiv auf Systemprobleme zu reagieren und die Gesamtleistung Ihrer IT-Umgebung zu optimieren.

21.3 Graphite und InnoDB im Vergleich

21.3.1 Einführung in Graphite

Graphite ist ein Open-Source-Überwachungswerkzeug, das speziell für die Erfassung, Speicherung und Visualisierung von Zeitreihendaten entwickelt wurde. Es ist eine leistungsfähige Lösung für die Überwachung von Systemen und Anwendungen und wird oft als Alternative zu Prometheus verwendet.

21.3.1.1 Komponenten von Graphite

Graphite besteht aus mehreren Hauptkomponenten, die zusammenarbeiten, um Daten zu sammeln, zu speichern und zu visualisieren:

1. Carbon:
   • Beschreibung: Carbon ist der Datensammler von Graphite. Es empfängt Metriken über das Netzwerk, verarbeitet sie und speichert sie in einer Zeitreihendatenbank.
   • Funktionen: Carbon besteht aus mehreren Komponenten:
     • carbon-cache: Caches Metriken und speichert sie in der Zeitreihendatenbank.
     • carbon-relay: Verteilt Metriken an mehrere carbon-cache-Instanzen.
     • carbon-aggregator: Aggregiert Metriken vor der Speicherung.
2. Whisper:
   • Beschreibung: Whisper ist die standardmäßige Zeitreihendatenbank von Graphite. Sie speichert die Metriken, die von Carbon empfangen werden.
   • Funktionen: Whisper speichert Daten in festen Intervallen und komprimiert ältere Daten, um Speicherplatz zu sparen.
3. Graphite Webapp:
   • Beschreibung: Die Graphite-Webanwendung bietet eine Benutzeroberfläche zur Visualisierung von Metriken und zur Erstellung von Dashboards.
   • Funktionen: Benutzer können Graphen erstellen, Metriken durchsuchen und Dashboards konfigurieren.

21.3.1.2 Installation von Graphite

Die Installation von Graphite kann auf verschiedenen Betriebssystemen erfolgen. Hier sind die grundlegenden Schritte zur Installation auf einem Linux-System.

1. Voraussetzungen:

   • Stellen Sie sicher, dass Python und pip auf Ihrem System installiert sind.

2. Installation:

   sudo apt update
   sudo apt install -y python3-pip
   sudo pip3 install whisper
   sudo pip3 install carbon
   sudo pip3 install graphite-web

3. Konfiguration von Carbon:

   • Bearbeiten Sie die Konfigurationsdateien für Carbon (carbon.conf und storage-schemas.conf):

     sudo nano /opt/graphite/conf/carbon.conf
     sudo nano /opt/graphite/conf/storage-schemas.conf

4. Konfiguration der Graphite-Webanwendung:

   • Bearbeiten Sie die Konfigurationsdatei local_settings.py:

     sudo nano /opt/graphite/webapp/graphite/local_settings.py

5. Starten der Dienste:

   • Starten Sie Carbon und die Graphite-Webanwendung:

     sudo /opt/graphite/bin/carbon-cache.py start
     sudo /opt/graphite/bin/run-graphite-devel-server.py /opt/graphite &

21.3.1.3 Konfiguration und Nutzung von Graphite

1. Konfiguration von Carbon:
   • carbon.conf: Konfiguriert die grundlegenden Einstellungen für Carbon, einschließlich Netzwerk- und Caching-Optionen.
   • storage-schemas.conf: Definiert, wie Metriken gespeichert werden, einschließlich der Aufbewahrungsdauer und Aggregationsmethoden.
2. Senden von Metriken an Graphite:

   • Metriken können über das Netzwerk an Carbon gesendet werden. Hier ist ein Beispiel für das Senden einer Metrik mit netcat:

     echo "servers.hostname.cpu.loadavg 42 `date +%s`" | nc -q0 localhost 2003

3. Visualisierung von Metriken:
   • Öffnen Sie die Graphite-Webanwendung in Ihrem Browser (standardmäßig unter http://localhost:8000).
   • Verwenden Sie die Weboberfläche, um Graphen zu erstellen und Metriken zu visualisieren.

21.3.1.4 Vorteile von Graphite

1. Skalierbarkeit:
   • Graphite ist darauf ausgelegt, große Mengen an Metriken zu verarbeiten und zu speichern. Durch die Verwendung von Carbon-Relay und mehreren Carbon-Cache-Instanzen kann Graphite horizontal skaliert werden.
2. Flexibilität:
   • Graphite bietet eine flexible Struktur zur Definition von Metriken und unterstützt verschiedene Aggregationsmethoden und Aufbewahrungszeiträume.
3. Visualisierung:
   • Die Graphite-Webanwendung ermöglicht die einfache Erstellung von Graphen und Dashboards, um die gesammelten Metriken zu visualisieren.

21.3.1.5 Herausforderungen und Nachteile von Graphite

1. Komplexität:
   • Die Konfiguration und Wartung von Graphite können komplex sein, insbesondere in großen und verteilten Umgebungen.
2. Speicherbedarf:
   • Die Whisper-Datenbank kann bei hohen Datenvolumen großen Speicherbedarf verursachen, insbesondere wenn lange Aufbewahrungszeiten konfiguriert sind.
3. Leistungsanforderungen:
   • Bei hohen Abfragevolumen kann die Leistung der Graphite-Webanwendung beeinträchtigt werden, was die Benutzerfreundlichkeit verringern kann.

Graphite ist ein leistungsfähiges Werkzeug zur Überwachung von Systemen und Anwendungen, das sich insbesondere durch seine Skalierbarkeit und Flexibilität auszeichnet. Durch die richtige Konfiguration und Nutzung kann Graphite wertvolle Einblicke in die Leistung und Gesundheit Ihrer IT-Umgebung bieten.

21.3.2 Vergleich der Datenbankmodelle

Graphite und InnoDB sind zwei unterschiedliche Systeme, die für unterschiedliche Zwecke entwickelt wurden. Während Graphite hauptsächlich für die Überwachung und Speicherung von Zeitreihendaten verwendet wird, ist InnoDB eine Speichermaschine für relationale Datenbanken wie MySQL. Hier werden die wichtigsten Unterschiede und Einsatzgebiete der beiden Systeme im Vergleich dargestellt.

21.3.2.1 Graphite

Graphite ist ein Open-Source-Tool, das speziell für die Erfassung, Speicherung und Visualisierung von Zeitreihendaten entwickelt wurde. Es besteht aus mehreren Komponenten, die zusammenarbeiten, um eine effiziente Überwachungslösung zu bieten.

1. Datenmodell:
   • Zeitreihenbasierte Speicherung: Graphite speichert Metriken als Zeitreihen, wobei jeder Datenpunkt aus einem Zeitstempel und einem Wert besteht.
   • Hierarchische Metrikennamen: Metriken werden hierarchisch mit Punktnotation benannt, z.B. servers.hostname.cpu.loadavg.
2. Speicherung:
   • Whisper-Datenbank: Graphite verwendet Whisper, eine spezielle Zeitreihendatenbank, die feste Intervall-Daten speichert und ältere Daten komprimiert.
   • Fixed-size Datenbanken: Whisper speichert Daten in festgelegten Intervallen und komprimiert ältere Daten, um den Speicherbedarf zu minimieren.
3. Abfragen und Visualisierung:
   • Graphite-Webapp: Bietet eine Weboberfläche zur Visualisierung von Metriken und Erstellung von Dashboards.
   • Abfragesprache: Unterstützt einfache Abfragen und Aggregationen von Metriken.
4. Einsatzgebiete:
   • Überwachung und Alerting: Ideal für die Überwachung von Systemen, Anwendungen und Netzwerken.
   • Kapazitätsplanung: Nützlich zur Analyse historischer Daten und Trends.

21.3.2.2 InnoDB

InnoDB ist eine der Haupt-Speichermaschinen für MySQL, einer relationalen Datenbank. InnoDB ist für Transaktionsverarbeitung, Datenintegrität und hohe Leistung optimiert.

1. Datenmodell:
   • Relationales Modell: Daten werden in Tabellen mit Zeilen und Spalten organisiert, und Beziehungen zwischen Tabellen werden durch Primär- und Fremdschlüssel hergestellt.
   • SQL-Abfragen: Unterstützt komplexe SQL-Abfragen, Joins, Transaktionen und Indexierung.
2. Speicherung:
   • ACID-konform: InnoDB garantiert Datenintegrität und -konsistenz durch Unterstützung von Transaktionen, die Atomarität, Konsistenz, Isolation und Dauerhaftigkeit (ACID) sicherstellen.
   • Row-level Locking: Unterstützt zeilenbasierte Sperren für hohe Parallelität und Leistung.
3. Abfragen und Visualisierung:
   • SQL-Abfragen: Ermöglicht komplexe Abfragen und Datenanalysen mit SQL.
   • Integrierte Tools: Unterstützt durch zahlreiche MySQL-Tools für Verwaltung, Backup und Wiederherstellung.
4. Einsatzgebiete:
   • Transaktionale Anwendungen: Ideal für Anwendungen, die hohe Datenintegrität und -konsistenz erfordern, wie z.B. Online-Shops, Banken und ERP-Systeme.
   • Analytische Anwendungen: Geeignet für Datenanalyse und Reporting in relationalen Datenmodellen.

21.3.2.3 Vergleich der wichtigsten Merkmale

21.3.2.4 Vorteile und Nachteile

1. Graphite:
   • Vorteile:
     • Optimiert für Zeitreihendaten und Überwachungsaufgaben.
     • Einfache Integration und Visualisierung von Metriken.
     • Gute Skalierbarkeit für große Mengen an Zeitreihendaten.
   • Nachteile:
     • Begrenzte Abfragemöglichkeiten im Vergleich zu SQL.
     • Keine Unterstützung für Transaktionen und relationale Daten.
2. InnoDB:
   • Vorteile:
     • ACID-konforme Transaktionen und hohe Datenintegrität.
     • Leistungsstarke SQL-Abfragen und Datenanalysen.
     • Weit verbreitet und gut unterstützte Speichermaschine für MySQL.
   • Nachteile:
     • Nicht optimiert für Zeitreihendaten.
     • Höherer Verwaltungsaufwand für große Datenmengen.

21.3.2.5 Anwendungsfälle

1. Graphite:
   • Überwachung von IT-Infrastrukturen: Sammeln und Visualisieren von Systemmetriken wie CPU-Auslastung, Speicherverbrauch und Netzwerktraffic.
   • Alerting: Einrichten von Alarmschwellen und Benachrichtigungen bei Überschreiten bestimmter Metriken.
2. InnoDB:
   • E-Commerce-Plattformen: Verwalten von Bestellungen, Kunden- und Produktinformationen mit hoher Transaktionssicherheit.
   • Finanzanwendungen: Durchführen von Transaktionen mit strengen Anforderungen an Datenintegrität und Konsistenz.

Durch das Verständnis der Unterschiede und Stärken von Graphite und InnoDB können Sie besser entscheiden, welches System für Ihre spezifischen Anforderungen am besten geeignet ist. Während Graphite ideal für die Überwachung und Speicherung von Zeitreihendaten ist, bietet InnoDB eine robuste Lösung für transaktionale und relationale Datenbanken.

21.3.3 Vor- und Nachteile

Graphite und InnoDB sind zwei sehr unterschiedliche Systeme, die jeweils spezifische Stärken und Schwächen aufweisen. Im Folgenden werden die Vor- und Nachteile beider Systeme detailliert beschrieben.

21.3.3.1 Graphite

Graphite ist ein Open-Source-Tool zur Überwachung und Visualisierung von Zeitreihendaten. Es besteht aus mehreren Komponenten, darunter Carbon, Whisper und die Graphite-Webanwendung.

Vorteile:

1. Optimiert für Zeitreihendaten:
   • Graphite ist speziell für die Erfassung, Speicherung und Visualisierung von Zeitreihendaten entwickelt worden. Dies macht es ideal für die Überwachung von Systemmetriken, Anwendungsmetriken und anderen zeitbasierten Daten.
2. Skalierbarkeit:
   • Graphite kann horizontal skaliert werden, indem mehrere Carbon-Cache-Instanzen und Carbon-Relays eingesetzt werden. Dies ermöglicht die Handhabung großer Mengen an Metriken.
3. Flexible Metrik-Definition:
   • Metriken in Graphite werden hierarchisch mit Punktnotation benannt, was eine flexible und intuitive Strukturierung ermöglicht.
4. Visualisierung:
   • Die Graphite-Webanwendung bietet leistungsstarke Visualisierungsmöglichkeiten für die erfassten Metriken. Benutzer können Graphen erstellen und Dashboards konfigurieren, um wichtige Metriken zu überwachen.

Nachteile:

1. Komplexität:
   • Die Konfiguration und Verwaltung von Graphite kann komplex und zeitaufwändig sein. Besonders in großen und verteilten Umgebungen ist die Einrichtung anspruchsvoll.
2. Speicherbedarf:
   • Die Whisper-Datenbank speichert Daten in festen Intervallen und kann bei hohen Datenvolumen einen erheblichen Speicherbedarf verursachen, insbesondere wenn lange Aufbewahrungszeiten konfiguriert sind.
3. Begrenzte Abfragemöglichkeiten:
   • Im Vergleich zu SQL-basierten Systemen bietet Graphite eingeschränkte Abfragemöglichkeiten. Komplexe Datenanalysen sind schwieriger durchzuführen.
4. Leistungsanforderungen:
   • Bei hohen Abfragevolumen kann die Leistung der Graphite-Webanwendung beeinträchtigt werden, was die Benutzerfreundlichkeit verringern kann.

21.3.3.2 InnoDB

InnoDB ist eine der Haupt-Speichermaschinen für MySQL und ist für transaktionale Anwendungen und relationale Datenbanken optimiert.

Vorteile:

1. ACID-Konformität:
   • InnoDB unterstützt ACID-konforme Transaktionen, die Atomarität, Konsistenz, Isolation und Dauerhaftigkeit gewährleisten. Dies stellt sicher, dass Datenintegrität und -konsistenz selbst bei Systemausfällen erhalten bleiben.
2. Leistungsstarke SQL-Abfragen:
   • InnoDB bietet umfassende Unterstützung für komplexe SQL-Abfragen, Joins, Indexierung und Datenanalysen. Dies ermöglicht eine flexible und leistungsstarke Datenverarbeitung.
3. Row-level Locking:
   • InnoDB verwendet zeilenbasierte Sperren, was hohe Parallelität und Leistung bei gleichzeitigen Datenbankzugriffen ermöglicht.
4. Weit verbreitet und gut unterstützt:
   • InnoDB ist weit verbreitet und wird von einer großen Community unterstützt. Es gibt zahlreiche Tools und Ressourcen zur Verwaltung, Backup und Wiederherstellung von InnoDB-Datenbanken.

Nachteile:

1. Nicht optimiert für Zeitreihendaten:
   • InnoDB ist nicht speziell für die Speicherung und Verarbeitung von Zeitreihendaten optimiert. Für Anwendungen, die hauptsächlich zeitbasierte Metriken erfassen, kann dies ineffizient sein.
2. Höherer Verwaltungsaufwand:
   • Die Verwaltung von InnoDB-Datenbanken kann komplex sein, insbesondere in großen Installationen mit vielen Tabellen und Datenbankinstanzen.
3. Speicher- und Leistungsbedarf:
   • InnoDB kann einen hohen Speicher- und Leistungsbedarf haben, insbesondere bei großen Datenmengen und intensiven Abfragen.

21.3.3.3 Zusammenfassung der Vor- und Nachteile

Durch das Verständnis der Vor- und Nachteile von Graphite und InnoDB können Sie besser entscheiden, welches System für Ihre spezifischen Anforderungen geeignet ist. Während Graphite ideal für die Überwachung und Speicherung von Zeitreihendaten ist, bietet InnoDB eine robuste Lösung für transaktionale und relationale Datenbanken.

21.3.4 Anwendungsfälle

Graphite und InnoDB dienen unterschiedlichen Zwecken und sind jeweils für spezifische Anwendungsfälle optimiert. Hier werden typische Szenarien und Anwendungsfälle für beide Systeme vorgestellt, um zu verdeutlichen, wann und wie sie am besten eingesetzt werden können.

21.3.4.1 Graphite

Graphite ist speziell für die Überwachung und Visualisierung von Zeitreihendaten entwickelt worden. Es eignet sich besonders gut für die Erfassung und Analyse von Metriken über die Zeit hinweg.

1. Systemüberwachung:
   • Anwendungsfall: Überwachung der Systemleistung von Servern und Workstations.
   • Beschreibung: Graphite kann verwendet werden, um Metriken wie CPU-Auslastung, Speichernutzung, Netzwerkverkehr und Festplatten-IO zu überwachen. Administratoren können Alarme konfigurieren, um benachrichtigt zu werden, wenn bestimmte Schwellenwerte überschritten werden.
   • Beispiel: Überwachen der CPU-Auslastung auf mehreren Servern, um Engpässe zu identifizieren und frühzeitig Maßnahmen zu ergreifen.
2. Anwendungsüberwachung:
   • Anwendungsfall: Überwachung der Leistung und Verfügbarkeit von Anwendungen.
   • Beschreibung: Graphite kann Metriken von Anwendungen sammeln, um deren Leistung zu überwachen und sicherzustellen, dass sie wie erwartet funktionieren. Entwickler können Metriken wie Anfragen pro Sekunde, Fehlerquoten und Antwortzeiten überwachen.
   • Beispiel: Überwachen der Antwortzeiten einer Webanwendung, um sicherzustellen, dass die Benutzererfahrung konsistent bleibt.
3. Netzwerküberwachung:
   • Anwendungsfall: Überwachung des Netzwerkverkehrs und der Netzwerkleistung.
   • Beschreibung: Graphite kann Netzwerkmetriken sammeln, um den Verkehr über verschiedene Schnittstellen zu überwachen und Engpässe zu identifizieren.
   • Beispiel: Überwachen des Netzwerkverkehrs auf einem Router, um sicherzustellen, dass die Bandbreitennutzung im erwarteten Bereich liegt.
4. Kapazitätsplanung:
   • Anwendungsfall: Planung der zukünftigen Ressourcenanforderungen.
   • Beschreibung: Durch die Analyse historischer Daten kann Graphite helfen, zukünftige Anforderungen vorherzusagen und Ressourcen entsprechend zu planen.
   • Beispiel: Analysieren der Speicherauslastung über das letzte Jahr, um festzustellen, wann zusätzliche Festplattenkapazität benötigt wird.
5. Alerting:
   • Anwendungsfall: Konfiguration von Alarmen zur Überwachung kritischer Metriken.
   • Beschreibung: Administratoren können Alarme konfigurieren, die bei Überschreiten bestimmter Schwellenwerte Benachrichtigungen auslösen.
   • Beispiel: Einrichten eines Alarms, der ausgelöst wird, wenn die CPU-Auslastung über 90% steigt.

21.3.4.2 InnoDB

InnoDB ist eine Speichermaschine für MySQL, die für transaktionale Anwendungen und relationale Datenbanken optimiert ist. Es eignet sich besonders gut für Anwendungen, die hohe Datenintegrität und -konsistenz erfordern.

1. E-Commerce-Plattformen:
   • Anwendungsfall: Verwalten von Bestellungen, Kunden- und Produktinformationen.
   • Beschreibung: InnoDB bietet ACID-konforme Transaktionen, die sicherstellen, dass alle Datenbankoperationen zuverlässig und konsistent ausgeführt werden. Dies ist entscheidend für E-Commerce-Anwendungen, bei denen die Integrität der Daten von größter Bedeutung ist.
   • Beispiel: Verwalten von Bestellungen und Lagerbeständen in einem Online-Shop, um sicherzustellen, dass alle Transaktionen korrekt und konsistent sind.
2. Finanzanwendungen:
   • Anwendungsfall: Durchführen von Finanztransaktionen mit strengen Anforderungen an Datenintegrität.
   • Beschreibung: InnoDB gewährleistet durch seine Transaktionssicherheit, dass alle Finanztransaktionen zuverlässig und konsistent verarbeitet werden, selbst bei Systemausfällen.
   • Beispiel: Verwalten von Bankkonten und Transaktionen, um sicherzustellen, dass alle Buchungen korrekt durchgeführt werden.
3. ERP-Systeme:
   • Anwendungsfall: Verwaltung von Geschäftsprozessen und Ressourcen.
   • Beschreibung: InnoDB kann verwendet werden, um die verschiedenen Module eines ERP-Systems zu unterstützen, einschließlich Bestandsverwaltung, Personalwesen und Buchhaltung. Die Transaktionssicherheit stellt sicher, dass alle Datenbankoperationen korrekt ausgeführt werden.
   • Beispiel: Verwaltung der Lieferkette in einem Produktionsunternehmen, um sicherzustellen, dass alle Bestellungen und Bestände genau erfasst werden.
4. Content-Management-Systeme (CMS):
   • Anwendungsfall: Verwaltung und Bereitstellung von Inhalten.
   • Beschreibung: InnoDB bietet die notwendige Datenbankunterstützung für CMS, um Inhalte sicher zu speichern und abzurufen. Dies umfasst Artikel, Benutzerprofile und Kommentare.
   • Beispiel: Betreiben einer Nachrichten-Website, die eine große Menge an Artikeln und Benutzerkommentaren verwaltet.
5. Datenanalyse und Reporting:
   • Anwendungsfall: Analysieren von Geschäftsdaten und Erstellen von Berichten.
   • Beschreibung: InnoDB unterstützt komplexe SQL-Abfragen und Datenanalysen, die für das Erstellen von Berichten und das Durchführen von Datenanalysen erforderlich sind.
   • Beispiel: Erstellen von Verkaufsberichten und Analysen zur Unterstützung der Geschäftsentscheidungen.

21.3.4.3 Zusammenfassung der Anwendungsfälle

Durch das Verständnis der spezifischen Anwendungsfälle für Graphite und InnoDB können Sie besser entscheiden, welches System für Ihre Anforderungen am besten geeignet ist. Graphite bietet eine hervorragende Lösung für die Überwachung und Visualisierung von Zeitreihendaten, während InnoDB eine robuste und zuverlässige Plattform für transaktionale und relationale Datenbankanwendungen darstellt.