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
- Wir melden uns in Grafana an.
- Navigieren zu "Configuration" > "Data Sources".
- Klicken auf "Add data source" und wählen "Prometheus".
- Nun geben wir die URL
http://prometheus:9090
ein und speichern die Konfiguration.
3.3 Erstellen eines Dashboards
- Wir gehen zu "Create" > "Dashboard".
- Dann fügen wir ein neues Panel hinzu und wählen eine Prometheus-Abfrage.
Beispiel:
node_cpu_seconds_total{job="node_exporter"}[5m]
- 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:
- Füge eine neue Datenquelle hinzu, wähle "Loki".
- 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
- Download des wmi_exporters:
- Lade den
wmi_exporter
von der offiziellen GitHub-Seite herunter.
- Lade den
- Installation:
- Installiere den Exporter als Windows-Dienst:
.\windows_exporter.exe --collectors.enabled "cpu,cs,logical_disk,net,os,system" --telemetry.addr ":9182" --install
- Installiere den Exporter als Windows-Dienst:
- Prometheus Konfiguration:
- Füge den Windows-Exporter zu deiner
prometheus.yml
hinzu:- job_name: 'windows' static_configs: - targets: ['<windows_ip>:9182']
- Füge den Windows-Exporter zu deiner
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.
- Docker-Setup:
- Stelle sicher, dass Docker auf deinem Windows-Server läuft.
- 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
- Starte cAdvisor als Docker-Container:
- Prometheus Konfiguration:
- Füge den cAdvisor-Endpunkt zu Prometheus hinzu:
- job_name: 'cadvisor' static_configs: - targets: ['<windows_ip>:8080']
- Füge den cAdvisor-Endpunkt zu Prometheus hinzu:
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
- Installation:
- Lade Promtail für Windows von der Grafana-Website herunter.
- 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}
- Erstelle eine
- Promtail starten:
- Starte Promtail:
.\promtail-windows-amd64.exe --config.file=promtail-config.yaml
- Starte Promtail:
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:
- Download:
- Lade Telegraf von der offiziellen InfluxData-Website herunter.
- 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"
- Erstelle eine Konfigurationsdatei
- Telegraf als Dienst installieren und starten:
.\telegraf.exe --service install --config telegraf.conf .\telegraf.exe --service start
- Prometheus Konfiguration:
- Füge den Telegraf-Prometheus-Endpunkt zu deiner
prometheus.yml
hinzu:- job_name: 'telegraf_windows' static_configs: - targets: ['<windows_ip>:9273']
- Füge den Telegraf-Prometheus-Endpunkt zu deiner
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:
- 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.
- 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
- 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:
- 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"
- 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']
- Füge die Telegraf-Instanzen zur
- 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:
- SNMP auf den Switches aktivieren:
- Stelle sicher, dass SNMP auf allen Switches aktiviert ist.
- 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
- Konfiguriere den SNMP Exporter, um Daten von den Switches zu sammeln:
- 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:
- NetFlow/sFlow auf den Switches aktivieren:
- Konfiguriere die Switches, um NetFlow oder sFlow Daten an einen Collector zu senden (z.B. nProbe).
- 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:
- SNMP auf den Routern und Firewalls aktivieren:
- Stelle sicher, dass SNMP auf allen Knotenpunkten aktiviert ist.
- 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
- Füge die Knotenpunkte zur
- 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:
- Syslog-Konfiguration auf den Geräten:
- Konfiguriere die Geräte, um Syslog-Daten an einen zentralen Server (z.B. Promtail/Loki) zu senden.
- 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}
- Konfiguriere Promtail, um die Syslog-Daten zu sammeln:
- 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:
- Volumes Definition:
- Unter
volumes
werden verschiedene Volumes wieprometheus_data
,grafana_data
,loki_data
undalertmanager_data
definiert. Diese Volumes sorgen dafür, dass Daten, die in den Containern gespeichert werden, auch bei Neustarts oder Neuinstallationen erhalten bleiben.
- Unter
- Externe Speicherung:
- Jedes Volume verwendet den
local
Driver mit dendriver_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.
- Jedes Volume verwendet den
- 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.
- Der Parameter
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
odermax
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.