Netzwerk- und Systemüberwachung

Diese Anleitung führt Schritt für Schritt durch die Einrichtung einer umfassenden Netzwerk- und Systemüberwachungslösung mit aktuellen Open-Source-Tools wie Prometheus, Grafana, Loki, cAdvisor, NodeExporter, Python Exportern, Alertmanager und Docker. Diese Tools zusammen ermöglichen eine robuste Überwachung, Analyse und Visualisierung von Netzwerk- und Systemmetriken in einer skalierbaren Weise.

Voraussetzungen

Diese kleine Anleitung richtet sich an Systemadministratoren, DevOps-Ingenieure, Entwickler und alle Personen die eine professionelle Überwachungslösung für ihre IT-Infrastruktur implementieren möchten.

  • Grundkenntnisse in Linux und Docker.
  • Eine Linux-Umgebung (z.B. Ubuntu 20.04).
  • Docker und Docker Compose.

Kurzüberblick

Zunächst ein Überblick über die genannten Überwachungstools:

1. Prometheus

Prometheus ist ein Open-Source-Monitoring- und Alerting-System, das speziell für die Überwachung von dynamischen und containerisierten Umgebungen entwickelt wurde. Es sammelt Metriken von verschiedenen Endpunkten über HTTP, speichert diese in einer zeitreihenbasierten Datenbank und ermöglicht die Abfrage und Analyse dieser Daten mit seiner leistungsfähigen Abfragesprache PromQL.

2. Grafana

Grafana ist ein Open-Source-Analyse- und Visualisierungstool, das zur Darstellung von Daten in Dashboards verwendet wird. Es unterstützt die Integration mit vielen Datenquellen, einschließlich Prometheus, und bietet umfangreiche Möglichkeiten zur Visualisierung und Überwachung von Metriken in Echtzeit.

3. Loki

Loki ist ein Open-Source-Log-Management-System, das für die effiziente Aggregation und Abfrage von Logdaten entwickelt wurde. Es ist eng in Grafana integriert und bietet eine kostengünstige Lösung für die Speicherung und Analyse von Logs, wobei es das gleiche Tagging-System wie Prometheus verwendet.

4. cAdvisor

cAdvisor (Container Advisor) ist ein Open-Source-Tool von Google, das speziell für die Überwachung der Ressourcennutzung und -leistung von Docker-Containern entwickelt wurde. Es sammelt Metriken wie CPU-, Speicher-, Netzwerk- und Festplattenverbrauch und stellt diese über eine Weboberfläche zur Verfügung.

5. NodeExporter

NodeExporter ist ein Prometheus-Exporter, der Systemmetriken von Linux-Servern sammelt, wie z.B. CPU- und Speicherverbrauch, Netzwerkstatistiken und Festplattenauslastung. Er ermöglicht eine umfassende Überwachung der Systemressourcen auf physischer und virtueller Hardware.

6. Python Exporter

Python Exporter ist eine Möglichkeit, eigene Metriken mit Python zu erstellen und diese an Prometheus zu übermitteln. Durch das Schreiben einfacher Python-Skripte können benutzerdefinierte Metriken, die für spezifische Anwendungsfälle relevant sind, gesammelt und überwacht werden.

7. Alertmanager

Alertmanager ist ein Begleitdienst zu Prometheus, der für das Management von Alarmen zuständig ist. Er sammelt Alarme von Prometheus, gruppiert sie, und sendet sie an verschiedene Empfänger wie E-Mail, Slack oder PagerDuty. Alertmanager ermöglicht auch die Konfiguration von Alarmregeln und Benachrichtigungsrichtlinien.

Ziele

  • Einrichten und Konfigurieren von Prometheus zur Sammlung und Speicherung von Metriken.
  • Visualisierung von Metriken mit Grafana.
  • Logging und Fehlerbehebung mit Loki.
  • Überwachung von Docker-Containern mit cAdvisor.
  • Überwachung von Linux-Systemen mit NodeExporter.
  • Erstellen eigener Metriken mit Python Exportern.
  • Überwachung von Ethereum-Knoten mit GETH.
  • Implementierung von Alarmierungen mit Alertmanager.
  • Integration der gesamten Lösung in einer Docker-Umgebung.

1. Installation und Konfiguration von Docker

Bevor wir mit den spezifischen Überwachungstools beginnen, benötigen wir Docker und Docker Compose, um die Dienste in Containern auszuführen.

1.1 Docker installieren

sudo apt update
sudo apt install -y docker.io
sudo systemctl start docker
sudo systemctl enable docker

1.2 Docker Compose installieren

sudo curl -L "https://github.com/docker/compose/releases/download/$(curl -s https://api.github.com/repos/docker/compose/releases/latest | grep -Po '"tag_name": "\K[0-9.]+')" /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
docker-compose --version

2. Einrichtung von Prometheus

2.1 Erstellen eines Prometheus Docker-Compose Setups

Erstelle ein Verzeichnis für das Projekt und eine docker-compose.yml Datei:

mkdir monitoring
cd monitoring
touch docker-compose.yml

In der docker-compose.yml Datei:

version: '3.8'

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"

  node_exporter:
    image: prom/node-exporter:latest
    container_name: node_exporter
    ports:
      - "9100:9100"

  cadvisor:
    image: google/cadvisor:latest
    container_name: cadvisor
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro

2.2 Prometheus-Konfigurationsdatei erstellen

Erstelle das Verzeichnis und die prometheus.yml Datei:

mkdir prometheus
touch prometheus/prometheus.yml

In der prometheus.yml Datei:

global:
  scrape_interval: 15s

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

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

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

2.3 Prometheus starten

Starte alle Dienste:

docker-compose up -d

Besuche http://localhost:9090 in deinem Browser, um die Prometheus-Oberfläche zu sehen.

3. Einrichtung von Grafana

3.1 Grafana konfigurieren

Nachdem Grafana gestartet ist, besuchen wir http://localhost:3000. Die Standard-Anmeldedaten sind admin für Benutzername und Passwort.

3.2 Prometheus als Datenquelle hinzufügen

  1. Wir melden uns in Grafana an.
  2. Navigieren zu "Configuration" > "Data Sources".
  3. Klicken auf "Add data source" und wählen "Prometheus".
  4. Nun geben wir die URL http://prometheus:9090 ein und speichern die Konfiguration.

3.3 Erstellen eines Dashboards

  1. Wir gehen zu "Create" > "Dashboard".
  2. Dann fügen wir ein neues Panel hinzu und wählen eine Prometheus-Abfrage. Beispiel:
    node_cpu_seconds_total{job="node_exporter"}[5m]
  3. Dann können wir das Dashboard speichern.

4. Logging mit Loki

4.1 Loki in Docker Compose hinzufügen

Erweitere deine docker-compose.yml:

  loki:
    image: grafana/loki:latest
    container_name: loki
    ports:
      - "3100:3100"
    command: -config.file=/etc/loki/local-config.yaml
    volumes:
      - ./loki/config:/etc/loki

  promtail:
    image: grafana/promtail:latest
    container_name: promtail
    volumes:
      - /var/log:/var/log
      - ./promtail/config:/etc/promtail

4.2 Loki-Konfiguration erstellen

Erstelle die loki/config Verzeichnisse und die local-config.yaml Datei:

mkdir -p loki/config
touch loki/config/local-config.yaml

In der local-config.yaml Datei:

auth_enabled: false

server:
  http_listen_port: 3100
  log_level: info

ingester:
  wal:
    enabled: true
    dir: /loki/wal
  lifecycler:
    ring:
      kvstore:
        store: inmemory
      replication_factor: 1

schema_config:
  configs:
    - from: 2020-10-24
      store: boltdb-shipper
      object_store: filesystem
      schema: v11
      index:
        prefix: index_
        period: 168h

storage_config:
  boltdb_shipper:
    active_index_directory: /loki/index
    cache_location: /loki/cache
    shared_store: filesystem
  filesystem:
    directory: /loki/chunks

limits_config:
  enforce_metric_name: false

chunk_store_config:
  max_look_back_period: 0s

table_manager:
  retention_deletes_enabled: true
  retention_period: 336h

4.3 Promtail konfigurieren

Erstelle das promtail/config Verzeichnis und die promtail.yaml Datei:

mkdir -p promtail/config
touch promtail/config/promtail.yaml

In der promtail.yaml Datei:

server:
  http_listen_port: 9080
  grpc_listen_port: 0

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://loki:3100/loki/api/v1/push

scrape_configs:
  - job_name: system
    static_configs:
      - targets:
          - localhost
        labels:
          job: varlogs
          __path__: /var/log/*.log

4.4 Loki und Promtail starten

Aktualisierung und Neustart der neuen Dienste:

docker-compose up -d loki promtail

In Grafana:

  1. Füge eine neue Datenquelle hinzu, wähle "Loki".
  2. Gib http://loki:3100 als URL ein und speichere.

5. Überwachung von Docker-Containern mit cAdvisor

5.1 cAdvisor ist bereits integriert

Wir haben cAdvisor bereits in der docker-compose.yml integriert. Seine Metriken können nun in Prometheus abgefragt und in Grafana visualisiert werden.

5.2 Beispiel für cAdvisor-Abfrage in Grafana

container_cpu_usage_seconds_total{container_name!=""}[5m]

6. Überwachung von Linux-Systemen mit NodeExporter

NodeExporter wurde bereits konfiguriert und seine Metriken werden von Prometheus gesammelt.

6.1 Beispiel für NodeExporter-Abfrage in Grafana

node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes * 100

7. Überwachung von Windows-Systemen

Um Windows-Systeme zu überwachen, gibt es verschiedene Tools und Methoden, die in die Überwachungsinfrastruktur integriert werden können. Die sind die gängigsten Methoden, um Metriken und Logs von Windows-Systemen zu erfassen und zu überwachen:

1. Node Exporter für Windows (wmi_exporter)

Der wmi_exporter (früher als windows_exporter bekannt) ist ein Prometheus-Exporter, der speziell für die Überwachung von Windows-Systemen entwickelt wurde. Er sammelt Metriken wie CPU-, Speicher- und Netzwerkressourcen sowie Windows-spezifische Metriken wie Windows-Dienste und -Prozesse.

Installation und Konfiguration

  1. Download des wmi_exporters:
    • Lade den wmi_exporter von der offiziellen GitHub-Seite herunter.
  2. Installation:
    • Installiere den Exporter als Windows-Dienst:
      .\windows_exporter.exe --collectors.enabled "cpu,cs,logical_disk,net,os,system" --telemetry.addr ":9182" --install
  3. Prometheus Konfiguration:
    • Füge den Windows-Exporter zu deiner prometheus.yml hinzu:
      - job_name: 'windows'
        static_configs:
          - targets: ['<windows_ip>:9182']

2. cAdvisor für Docker-Container auf Windows

Wenn man Docker auf Windows verwendet, kann man cAdvisor zur Überwachung von Containerressourcen einsetzen. Die Konfiguration erfolgt ähnlich wie bei Linux-Containern.

  1. Docker-Setup:
    • Stelle sicher, dass Docker auf deinem Windows-Server läuft.
  2. cAdvisor starten:
    • Starte cAdvisor als Docker-Container:
      docker run -d --name=cadvisor -p 8080:8080 --volume=/:/rootfs:ro --volume=/var/run:/var/run:rw --volume=/sys:/sys:ro --volume=/var/lib/docker/:/var/lib/docker:ro google/cadvisor:latest
  3. Prometheus Konfiguration:
    • Füge den cAdvisor-Endpunkt zu Prometheus hinzu:
      - job_name: 'cadvisor'
        static_configs:
          - targets: ['<windows_ip>:8080']

3. Windows Event Logs mit Loki überwachen

Windows-Event-Logs können mit dem Log-Management-Tool Loki überwacht werden. Dazu können verschiedene Tools eingesetzt werden, wie z.B. der Promtail-Agent von Grafana, um Logs von Windows an Loki zu senden.

Promtail für Windows

  1. Installation:
  2. Konfiguration:
    • Erstelle eine promtail-config.yaml:
      server:
        http_listen_port: 9080
        grpc_listen_port: 0
      positions:
        filename: /var/log/positions.yaml
      clients:
        - url: http://<loki_address>:3100/loki/api/v1/push
      scrape_configs:
        - job_name: windows
          static_configs:
            - targets:
              - localhost
          entry_parser: raw
          pipeline_stages:
            - json:
                expressions:
                  level: Level
                  msg: Message
                  caller: Source
          journal:
            path: C:\Windows\System32\winevt\Logs\System.evtx
            labels:
              job: windows_logs
              host: ${HOSTNAME}
  3. Promtail starten:
    • Starte Promtail:
      .\promtail-windows-amd64.exe --config.file=promtail-config.yaml

4. Integration mit Grafana

Die gesammelten Metriken und Logs von Windows-Systemen können in Grafana-Dashboards visualisiert werden. Verwende hierfür die entsprechenden Datenquellen (Prometheus für Metriken, Loki für Logs) und erstelle benutzerdefinierte Dashboards.

Beispiele für Grafana-Dashboards:

  • Systemüberwachung: CPU-Auslastung, Arbeitsspeicher, Festplattennutzung.
  • Netzwerküberwachung: Netzwerkdurchsatz, Netzwerkfehler.
  • Event-Log-Überwachung: Überwachung kritischer Events im Windows-Event-Log.

5. Verwendung von Telegraf

Telegraf ist ein flexibler Agent zur Sammlung von Metriken und Logs, der sowohl für Windows als auch für Linux verfügbar ist. Telegraf kann Daten an verschiedene Datenbanken senden, darunter Prometheus und InfluxDB.

Telegraf Installation auf Windows:

  1. Download:
  2. Konfiguration:
    • Erstelle eine Konfigurationsdatei telegraf.conf:
      [[inputs.win_perf_counters]]
        [[inputs.win_perf_counters.object]]
          ObjectName = "Processor"
          Counters = ["% Processor Time", "% Idle Time"]
          Instances = ["_Total"]
          Measurement = "win_cpu"
        [[inputs.win_perf_counters.object]]
          ObjectName = "Memory"
          Counters = ["Available Bytes"]
          Instances = ["------"]
          Measurement = "win_mem"
        [[inputs.win_perf_counters.object]]
          ObjectName = "Network Interface"
          Counters = ["Bytes Received/sec", "Bytes Sent/sec"]
          Instances = ["*"]
          Measurement = "win_net"
      [[outputs.prometheus_client]]
        listen = ":9273"
  3. Telegraf als Dienst installieren und starten:
    .\telegraf.exe --service install --config telegraf.conf
    .\telegraf.exe --service start
  4. Prometheus Konfiguration:
    • Füge den Telegraf-Prometheus-Endpunkt zu deiner prometheus.yml hinzu:
      - job_name: 'telegraf_windows'
        static_configs:
          - targets: ['<windows_ip>:9273']

Durch die Integration von Client-Tools wie wmi_exporter, cAdvisor, Promtail, und Telegraf kann man eine umfassende Überwachung der Windows-Systeme sicherstellen. Diese Daten können dann in Prometheus und Loki gesammelt und in Grafana visualisiert werden, was eine zentrale und umfassende Ansicht der Windows-Infrastruktur ermöglicht.

8. Integrationsbeispiele von weiteren Knotenpunkten, Switches und Clients

Kombination verschiedener Tools und Techniken. Basierend auf der oben beschriebenen Konfiguration (die SNMP, Prometheus, Grafana, Loki, und andere Tools verwendet), kann eine umfassende Überwachungsinfrastruktur aufgebaut werden:

1. Überwachung von Clients

a. SNMP-basierte Überwachung

  • SNMP (Simple Network Management Protocol) ist eine bewährte Methode, um Systemmetriken von Clients (z.B. Desktops, Laptops) zu erfassen.

Schritte:

  1. SNMP auf den Clients aktivieren:
    • Für Windows: Über die Systemsteuerung kannst du SNMP-Dienste aktivieren und konfigurieren.
    • Für Linux: Installiere das snmpd-Paket und konfiguriere es entsprechend.
  2. Konfiguration des SNMP Exporters für Prometheus:
    • Installiere den SNMP Exporter auf deinem Prometheus-Server.
    • Konfiguriere prometheus.yml, um Metriken von den Clients zu sammeln:
      scrape_configs:
        - job_name: 'clients'
          static_configs:
            - targets: ['192.168.1.100:161', '192.168.1.101:161']
          metrics_path: /snmp
          params:
            module: [client_mib]
          relabel_configs:
            - source_labels: [__address__]
              target_label: __param_target
            - source_labels: [__param_target]
              target_label: instance
            - target_label: __address__
              replacement: 127.0.0.1:9116  # SNMP Exporter Adresse
  3. Visualisierung in Grafana:
    • Verwende Grafana, um Dashboards zu erstellen, die Metriken wie CPU-Auslastung, Speichernutzung und Netzwerkverkehr für jeden Client anzeigen.

b. Agent-basierte Überwachung (Telegraf/Node Exporter)

  • Agenten wie Telegraf oder Node Exporter können auf den Clients installiert werden, um detaillierte Metriken zu sammeln.

Schritte:

  1. Installation und Konfiguration von Telegraf:
    • Installiere Telegraf auf jedem Client.
    • Konfiguriere Telegraf, um Metriken zu sammeln und an Prometheus zu senden:
      [[inputs.cpu]]
        percpu = true
        totalcpu = true
        fielddrop = ["time_*"]
      [[inputs.mem]]
      [[inputs.net]]
      [[outputs.prometheus_client]]
        listen = ":9273"
  2. Prometheus Konfiguration:
    • Füge die Telegraf-Instanzen zur prometheus.yml hinzu:
      - job_name: 'telegraf_clients'
        static_configs:
          - targets: ['192.168.1.100:9273', '192.168.1.101:9273']
  3. Visualisierung in Grafana:
    • Erstelle Dashboards, um die gesammelten Metriken von den Clients anzuzeigen.

2. Überwachung von Switches

a. SNMP-basierte Überwachung

Switches sind zentrale Netzwerkknoten, und SNMP ist das Standardprotokoll zur Überwachung von Netzwerkgeräten.

Schritte:

  1. SNMP auf den Switches aktivieren:
    • Stelle sicher, dass SNMP auf allen Switches aktiviert ist.
  2. Konfiguration des SNMP Exporters:
    • Konfiguriere den SNMP Exporter, um Daten von den Switches zu sammeln:
      - job_name: 'switches'
        static_configs:
          - targets: ['192.168.1.20:161', '192.168.1.21:161']
        metrics_path: /snmp
        params:
          module: [if_mib]
        relabel_configs:
          - source_labels: [__address__]
            target_label: __param_target
          - source_labels: [__param_target]
            target_label: instance
          - target_label: __address__
            replacement: 127.0.0.1:9116  # SNMP Exporter Adresse
  3. Visualisierung in Grafana:
    • Erstelle Dashboards für Switch-Metriken wie Portstatus, Bandbreitennutzung und Fehlerstatistiken.

b. NetFlow/sFlow Monitoring

Zusätzlich zu SNMP kann NetFlow oder sFlow zur Überwachung des Netzwerkverkehrs verwendet werden.

Schritte:

  1. NetFlow/sFlow auf den Switches aktivieren:
    • Konfiguriere die Switches, um NetFlow oder sFlow Daten an einen Collector zu senden (z.B. nProbe).
  2. Integration in Grafana:
    • Verwende nProbe und ntopng, um den Netzwerkverkehr zu analysieren und die Daten in Grafana zu visualisieren.

3. Überwachung von Knotenpunkten (Router, Firewalls)

a. SNMP-basierte Überwachung

SNMP ist auch hier die bevorzugte Methode zur Überwachung von Knotenpunkten.

Schritte:

  1. SNMP auf den Routern und Firewalls aktivieren:
    • Stelle sicher, dass SNMP auf allen Knotenpunkten aktiviert ist.
  2. SNMP Exporter Konfiguration:
    • Füge die Knotenpunkte zur prometheus.yml hinzu:
      - job_name: 'routers_firewalls'
        static_configs:
          - targets: ['192.168.1.1:161', '192.168.1.2:161']
        metrics_path: /snmp
        params:
          module: [if_mib, bgp, firewall]
        relabel_configs:
          - source_labels: [__address__]
            target_label: __param_target
          - source_labels: [__param_target]
            target_label: instance
          - target_label: __address__
            replacement: 127.0.0.1:9116  # SNMP Exporter Adresse
  3. Visualisierung in Grafana:
    • Erstelle Dashboards für Metriken wie Interface-Status, BGP-Routen und Firewall-Regeln.

b. Log-Überwachung mit Syslog

Die Überwachung von Syslog-Daten von Knotenpunkten wie Routern und Firewalls ist ebenfalls wichtig.

Schritte:

  1. Syslog-Konfiguration auf den Geräten:
    • Konfiguriere die Geräte, um Syslog-Daten an einen zentralen Server (z.B. Promtail/Loki) zu senden.
  2. Promtail Konfiguration:
    • Konfiguriere Promtail, um die Syslog-Daten zu sammeln:
      scrape_configs:
        - job_name: 'syslog_routers_firewalls'
          syslog:
            listen_address: 0.0.0.0:514
            labels:
              job: syslog
              host: ${HOSTNAME}
  3. Visualisierung in Grafana:
    • Erstelle Dashboards, um sicherheitsrelevante Ereignisse und Netzwerkprobleme zu überwachen.

Durch die sinnvolle Integration von SNMP, Agenten-basierten Tools wie Telegraf und Node Exporter, NetFlow/sFlow, und Syslog-Daten in die Überwachungsinfrastruktur, kann man eine komplett umfassende und detaillierte Überwachung der gesamten Netzwerkumgebung einschließlich Clients, Switches und Knotenpunkten sicherstellen. Grafana dient dabei als zentrale Visualisierungsplattform, um alle gesammelten Daten in benutzerfreundlichen Dashboards darzustellen.

9. Eigene Metriken mit Python Exportern erstellen

7.1 Einrichten eines einfachen Python Exporters

Erstelle einen einfachen Python Exporter:

from prometheus_client import start_http_server, Summary
import random
import time

REQUEST_TIME = Summary('request_processing_seconds', 'Time spent processing request')

@REQUEST_TIME.time()
def process_request(t):
    time.sleep(t)

if __name__ == '__main__':
    start_http_server(8000)
    while True:
        process_request(random.random())

7.2 Python Exporter in Docker integrieren

Erstelle eine Dockerfile:

FROM python:3.8

RUN pip install prometheus_client

COPY your_exporter.py /your_exporter.py

CMD ["python", "/your_exporter.py"]

In docker-compose.yml:

  python_exporter:
    build: .
    ports:
      - "8000:8000"

10. Alarmierung mit Alertmanager

9.1 Alertmanager in Docker Compose hinzufügen

Erweitere deine docker-compose.yml:

  alertmanager:
    image: prom/alertmanager
    ports:
      - "9093:9093"
    volumes:
      - ./alertmanager/config.yml:/etc/alertmanager/config.yml

9.2 Alertmanager Konfiguration

Erstelle die alertmanager/config.yml:

global:
  resolve_timeout: 5m

route:
  receiver: 'email-notifications'

receivers:
  - name: 'email-notifications'
    email_configs:
      - to: 'youremail@example.com'
        from: 'alertmanager@example.com'
        smarthost: 'smtp.example.com:587'
        auth_username: 'your_username'
        auth_identity: 'your_username'
        auth_password: 'your_password'

9.3 Prometheus konfigurieren, um mit Alertmanager zu arbeiten

In der prometheus.yml Datei:

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

rule_files:
  - "alert.rules.yml"

9.4 Beispiel für Alert-Regeln

Erstelle eine Datei alert.rules.yml:

groups:
  - name: example
    rules:
    - alert: HighMemoryUsage
      expr: node_memory_Active_bytes / node_memory_MemTotal_bytes * 100 > 80
      for: 1m
      labels:
        severity: warning
      annotations:
        summary: "High Memory Usage"
        description: "Memory usage is above 80%."

Starte Alertmanager:

docker-compose up -d alertmanager

11. Integration und Betrieb

11.1 Docker Compose Setup

docker-compose up -d

11.2 Backup und Skalierung

Um Daten zu sichern, sollte man die Volumes in einer docker-compose.yml definieren und extern speichern. Im folgenden Fall werden mehrere Volumes definiert, um Daten von verschiedenen Containern extern zu speichern und somit dauerhaft zu sichern:

version: '3.8'

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - prometheus_data:/etc/prometheus
    ports:
      - "9090:9090"

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    volumes:
      - grafana_data:/var/lib/grafana
    ports:
      - "3000:3000"

  loki:
    image: grafana/loki:latest
    container_name: loki
    ports:
      - "3100:3100"
    command: -config.file=/etc/loki/local-config.yaml
    volumes:
      - loki_data:/loki

  alertmanager:
    image: prom/alertmanager:latest
    container_name: alertmanager
    ports:
      - "9093:9093"
    volumes:
      - alertmanager_data:/etc/alertmanager

volumes:
  prometheus_data:
    driver: local
    driver_opts:
      type: none
      device: /path/to/external/storage/prometheus
      o: bind

  grafana_data:
    driver: local
    driver_opts:
      type: none
      device: /path/to/external/storage/grafana
      o: bind

  loki_data:
    driver: local
    driver_opts:
      type: none
      device: /path/to/external/storage/loki
      o: bind

  alertmanager_data:
    driver: local
    driver_opts:
      type: none
      device: /path/to/external/storage/alertmanager
      o: bind

11.3. Erklärung:

  1. Volumes Definition:
    • Unter volumes werden verschiedene Volumes wie prometheus_data, grafana_data, loki_data und alertmanager_data definiert. Diese Volumes sorgen dafür, dass Daten, die in den Containern gespeichert werden, auch bei Neustarts oder Neuinstallationen erhalten bleiben.
  2. Externe Speicherung:
    • Jedes Volume verwendet den local Driver mit den driver_opts, um den Speicherort auf dem Host zu definieren. Hierbei wird das Volume mit einem externen Verzeichnis auf dem Hostsystem verknüpft.
    • Beispiel: device: /path/to/external/storage/prometheus bindet das Verzeichnis /path/to/external/storage/prometheus auf dem Host an das interne Verzeichnis /etc/prometheus im Prometheus-Container.
  3. Bind-Mount:
    • Der Parameter o: bind gibt an, dass ein Bind-Mount verwendet wird, was bedeutet, dass ein Verzeichnis auf dem Hostsystem direkt mit einem Verzeichnis im Container verbunden wird. Änderungen in einem Verzeichnis werden automatisch in das andere gespiegelt.

11.4. Nutzung:

Um die Dienste mit dieser Konfiguration zu starten und die Volumes zu verwenden, führen wir den folgenden Befehl aus:

docker-compose up -d

Dies stellt sicher, dass die Daten der einzelnen Container dauerhaft auf dem Hostsystem gespeichert werden und somit bei einem Verlust oder Neustart der Container nicht verloren gehen.

10.3 Troubleshooting und Optimierung

Überprüfe die Logs:

docker logs <container_name>

12. Optimierung der PromQL-Abfragen

Die Optimierung von PromQL-Abfragen ist entscheidend, um die Leistung von Prometheus-Dashboards zu verbessern, insbesondere wenn du eine große Anzahl von Metriken oder große Datenmengen verarbeitest. Hier sind einige Best Practices und Tipps zur Optimierung:

1. Zeitintervalle gezielt verwennden

  • Präzisiere Zeitintervalle: Verwende präzise Zeitintervalle für Abfragen, anstatt die Standardwerte zu übernehmen. Dies reduziert die Menge der verarbeiteten Daten.
    rate(http_requests_total[5m])

    Hier wird der Datenfluss nur für die letzten 5 Minuten berechnet, statt für längere Zeiträume.

  • Vermeide unnötig große Zeitbereiche: Führe keine Abfragen über unnötig große Zeiträume durch. Wähle nur die Zeitspanne, die für das Dashboard notwendig ist.
    avg_over_time(node_cpu_seconds_total[1h])

2. Nutze rate statt irate für glattere Trends

  • Rate für längere Zeiträume: rate liefert glattere Ergebnisse über längere Zeiträume, was weniger Schwankungen in Dashboards zeigt.
    rate(node_cpu_seconds_total{mode="idle"}[5m])

    Statt:

    irate(node_cpu_seconds_total{mode="idle"}[5m])

3. Verwende sum und group zur Aggregation

  • Aggregiere Metriken: Wenn du Metriken aggregieren kannst, verwende sum, avg oder max statt detaillierte Datenpunkte zu visualisieren. Dies reduziert die Anzahl der Zeitreihen.
    sum(rate(http_requests_total[5m])) by (job)

    Statt:

    rate(http_requests_total[5m])

4. Reduziere Label-Dimensionen

  • Entferne unnötige Labels: Vermeide Labels, die für die Abfrage nicht relevant sind, um die Komplexität zu reduzieren.
    sum by (job) (rate(node_cpu_seconds_total{mode="idle"}[5m]))

    Statt:

    sum by (job, instance) (rate(node_cpu_seconds_total{mode="idle"}[5m]))

5. Verwende subquery für effiziente Abfragen

  • Subqueries für präzise Aggregationen: Nutze Subqueries, um Aggregationen effizienter zu gestalten, insbesondere bei längeren Zeiträumen.
    avg_over_time(
      sum by (instance) (
        rate(node_cpu_seconds_total{mode="idle"}[5m])
      )[1h:10m]
    )

    Diese Abfrage berechnet eine 10-minütige durchschnittliche CPU-Nutzung über 1 Stunde.

6. Verwende offset für historische Vergleiche

  • Historische Vergleiche: Nutze offset, um aktuelle Werte mit historischen zu vergleichen, ohne auf alte Daten direkt zuzugreifen.
    rate(node_cpu_seconds_total[5m]) / rate(node_cpu_seconds_total[5m] offset 1d)

    Dies vergleicht die aktuelle CPU-Auslastung mit der von gestern.

7. Überwache und reduziere die Abfragekomplexität

  • Vermeide Verschachtelungen: Zu viele verschachtelte Funktionen können die Abfrage unnötig komplizieren und die Berechnungszeit verlängern. Verwende stattdessen flachere Abfragen.
    sum(rate(http_requests_total[5m])) by (job)

    Statt zu viele Funktionen in einer einzigen Abfrage zu verschachteln.

8. Nutze recording rules

  • Vordefinierte Berechnungen: Verwende recording rules, um komplexe Berechnungen vorzuberechnen und Ergebnisse zu speichern. Dadurch werden Dashboards schneller geladen.
    groups:
    - name: example
      rules:
      - record: job:http_inprogress_requests:sum
        expr: sum(http_inprogress_requests) by (job)

Diese Regel speichert die Summe von http_inprogress_requests unter einem neuen Namen, was die spätere Verwendung in Dashboards beschleunigt.

9. Datenreduzierung durch Filterung

  • Gezielte Filterung: Reduziere die Datenmenge durch gezielte Filterung von Labels, um nur relevante Metriken zu verarbeiten.
    rate(http_requests_total{status="200"}[5m])

    Statt:

    rate(http_requests_total[5m])

10. Regelmäßige Überprüfung der Abfragen

  • Überprüfe und optimiere Abfragen regelmäßig: Da sich Metriken und Anforderungen ändern können, ist es wichtig, Abfragen regelmäßig zu überprüfen und zu optimieren, um sicherzustellen, dass sie weiterhin effizient sind.

Indem man diese Optimierungen anwendet, kann man die Leistung der Prometheus-Abfragen und Grafana-Dashboards erheblich verbessern. Dies führt zu schnelleren Ladezeiten, geringerer CPU-Auslastung auf dem Prometheus-Server und einer insgesamt besseren Benutzererfahrung in der Dashboards.

Zusammenfassung

Diese Anleitung hat gezeigt, wie man eine vollständige Überwachungsinfrastruktur mit Prometheus, Grafana, Loki, cAdvisor, NodeExporter, Python Exportern und Alertmanager einrichten kann. Mit diesen Tools kann man effektiv die Leistung aller Systeme und Netzwerkknotenpunkten überwachen und immer weiter optimieren.