Grafana und InfluxDB bilden ein leistungsfähiges Duo für Server-Monitoring. InfluxDB speichert Zeitreihen-Daten, Grafana visualisiert sie in schönen Dashboards.
Architektur
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Server │────>│ Telegraf │────>│ InfluxDB │
│ (Metrics) │ │ (Sammler) │ │ (Datenbank) │
└─────────────┘ └─────────────┘ └─────────────┘
│
▼
┌─────────────┐
│ Grafana │
│ (Dashboard) │
└─────────────┘InfluxDB installieren
InfluxDB 2.x (empfohlen)
# Repository hinzufügen
wget -q https://repos.influxdata.com/influxdata-archive_compat.key
echo '393e8779c89ac8d958f81f942f9ad7fb82a25e133faddaf92e15b16e6ac9ce4c influxdata-archive_compat.key' | sha256sum -c && cat influxdata-archive_compat.key | gpg --dearmor | tee /etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg > /dev/null
echo 'deb [signed-by=/etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg] https://repos.influxdata.com/debian stable main' | tee /etc/apt/sources.list.d/influxdata.list
# Installieren
apt update
apt install influxdb2
# Starten
systemctl enable --now influxdbInitiale Konfiguration
# Setup über CLI
influx setup
# Oder über Web-UI: http://server-ip:8086Setup-Eingaben:
- Username: admin
- Password: sicheres-passwort
- Organization: meine-firma
- Bucket: server-metrics
Token für Zugriff
# Token anzeigen
influx auth list
# Neues Token erstellen
influx auth create -o meine-firma --read-buckets --write-bucketsTelegraf installieren (Datensammler)
Installation
apt install telegrafGrundkonfiguration
# /etc/telegraf/telegraf.conf
[global_tags]
hostname = "webserver1"
[agent]
interval = "10s"
round_interval = true
metric_batch_size = 1000
metric_buffer_limit = 10000
collection_jitter = "0s"
flush_interval = "10s"
flush_jitter = "0s"
# Output zu InfluxDB 2.x
[[outputs.influxdb_v2]]
urls = ["http://localhost:8086"]
token = "IHR_TOKEN"
organization = "meine-firma"
bucket = "server-metrics"
# Inputs
[[inputs.cpu]]
percpu = true
totalcpu = true
collect_cpu_time = false
report_active = false
[[inputs.disk]]
ignore_fs = ["tmpfs", "devtmpfs", "devfs", "iso9660", "overlay", "aufs", "squashfs"]
[[inputs.diskio]]
[[inputs.kernel]]
[[inputs.mem]]
[[inputs.processes]]
[[inputs.swap]]
[[inputs.system]]
[[inputs.net]]
interfaces = ["eth0"]Erweiterte Inputs
# Nginx Status
[[inputs.nginx]]
urls = ["http://localhost/nginx_status"]
# MySQL
[[inputs.mysql]]
servers = ["user:password@tcp(localhost:3306)/"]
# Docker
[[inputs.docker]]
endpoint = "unix:///var/run/docker.sock"
# Apache
[[inputs.apache]]
urls = ["http://localhost/server-status?auto"]Telegraf starten
# Konfiguration testen
telegraf --config /etc/telegraf/telegraf.conf --test
# Starten
systemctl enable --now telegrafGrafana installieren
Installation
# Repository hinzufügen
apt install -y apt-transport-https software-properties-common
wget -q -O /usr/share/keyrings/grafana.key https://apt.grafana.com/gpg.key
echo "deb [signed-by=/usr/share/keyrings/grafana.key] https://apt.grafana.com stable main" | tee -a /etc/apt/sources.list.d/grafana.list
# Installieren
apt update
apt install grafana
# Starten
systemctl enable --now grafana-serverErster Login
- URL: http://server-ip:3000
- User: admin
- Passwort: admin (beim ersten Login ändern)
Grafana mit InfluxDB verbinden
Datenquelle hinzufügen
1. Configuration → Data Sources → Add data source 2. InfluxDB auswählen 3. Konfiguration:
Query Language: Flux (für InfluxDB 2.x)
URL: http://localhost:8086
Organization: meine-firma
Token: IHR_TOKEN
Default Bucket: server-metrics4. Save & Test
Dashboard erstellen
Neues Dashboard
1. + → Dashboard → Add visualization 2. Datenquelle auswählen: InfluxDB
CPU-Auslastung Panel
Flux Query:
from(bucket: "server-metrics")
|> range(start: v.timeRangeStart, stop: v.timeRangeStop)
|> filter(fn: (r) => r["_measurement"] == "cpu")
|> filter(fn: (r) => r["_field"] == "usage_idle")
|> filter(fn: (r) => r["cpu"] == "cpu-total")
|> map(fn: (r) => ({r with _value: 100.0 - r._value}))
|> aggregateWindow(every: v.windowPeriod, fn: mean)RAM-Nutzung Panel
from(bucket: "server-metrics")
|> range(start: v.timeRangeStart, stop: v.timeRangeStop)
|> filter(fn: (r) => r["_measurement"] == "mem")
|> filter(fn: (r) => r["_field"] == "used_percent")
|> aggregateWindow(every: v.windowPeriod, fn: mean)Disk-Nutzung Panel
from(bucket: "server-metrics")
|> range(start: v.timeRangeStart, stop: v.timeRangeStop)
|> filter(fn: (r) => r["_measurement"] == "disk")
|> filter(fn: (r) => r["_field"] == "used_percent")
|> filter(fn: (r) => r["path"] == "/")
|> aggregateWindow(every: v.windowPeriod, fn: mean)Netzwerk-Traffic Panel
from(bucket: "server-metrics")
|> range(start: v.timeRangeStart, stop: v.timeRangeStop)
|> filter(fn: (r) => r["_measurement"] == "net")
|> filter(fn: (r) => r["_field"] == "bytes_recv" or r["_field"] == "bytes_sent")
|> filter(fn: (r) => r["interface"] == "eth0")
|> derivative(unit: 1s, nonNegative: true)
|> aggregateWindow(every: v.windowPeriod, fn: mean)Alerts einrichten
Alert-Regel erstellen
1. Im Panel: Edit → Alert 2. Create alert rule from this panel
Evaluate every: 1m
For: 5m
Conditions:
- WHEN avg() OF query(A, 5m, now) IS ABOVE 90Notification Channel
1. Alerting → Notification channels → Add channel 2. Typ auswählen: E-Mail, Slack, Telegram, etc.
E-Mail:
Name: Email-Alert
Type: Email
Addresses: admin@example.comSlack:
Name: Slack-Alert
Type: Slack
Webhook URL: https://hooks.slack.com/services/XXX/YYY/ZZZVorgefertigte Dashboards
Dashboard importieren
1. + → Import 2. Dashboard-ID eingeben oder JSON hochladen
Beliebte Dashboard-IDs:
- 1860: Node Exporter Full
- 928: Telegraf System Dashboard
- 11074: Node Exporter for Prometheus
Telegraf Dashboard
ID: 928 (oder nach "Telegraf" suchen)
Docker-basierte Installation
# docker-compose.yml
version: '3.8'
services:
influxdb:
image: influxdb:2.7
ports:
- "8086:8086"
volumes:
- influxdb-data:/var/lib/influxdb2
environment:
- DOCKER_INFLUXDB_INIT_MODE=setup
- DOCKER_INFLUXDB_INIT_USERNAME=admin
- DOCKER_INFLUXDB_INIT_PASSWORD=sicheres-passwort
- DOCKER_INFLUXDB_INIT_ORG=meine-firma
- DOCKER_INFLUXDB_INIT_BUCKET=server-metrics
- DOCKER_INFLUXDB_INIT_ADMIN_TOKEN=mein-super-geheimes-token
telegraf:
image: telegraf:1.28
volumes:
- ./telegraf.conf:/etc/telegraf/telegraf.conf:ro
- /var/run/docker.sock:/var/run/docker.sock:ro
depends_on:
- influxdb
grafana:
image: grafana/grafana:10
ports:
- "3000:3000"
volumes:
- grafana-data:/var/lib/grafana
depends_on:
- influxdb
volumes:
influxdb-data:
grafana-data:docker compose up -dRetention Policies
Datenaufbewahrung konfigurieren
# In InfluxDB CLI
influx bucket update \
--id BUCKET_ID \
--retention 30dOder über Web-UI: Data → Buckets → Settings
Downsampling für langfristige Daten
// Task für tägliche Aggregation
option task = {name: "downsample_daily", every: 1d}
from(bucket: "server-metrics")
|> range(start: -1d)
|> filter(fn: (r) => r["_measurement"] == "cpu")
|> aggregateWindow(every: 1h, fn: mean)
|> to(bucket: "server-metrics-longterm", org: "meine-firma")Troubleshooting
Keine Daten in Grafana
# Telegraf-Logs prüfen
journalctl -u telegraf -f
# InfluxDB-Daten prüfen
influx query 'from(bucket:"server-metrics") |> range(start:-1h) |> limit(n:10)'Verbindungsprobleme
# InfluxDB erreichbar?
curl http://localhost:8086/health
# Token korrekt?
curl -H "Authorization: Token IHR_TOKEN" http://localhost:8086/api/v2/bucketsHoher Speicherverbrauch
# Retention Policy prüfen und anpassen
influx bucket list
influx bucket update --id BUCKET_ID --retention 7dZusammenfassung
| Komponente | Port | Funktion | |------------|------|----------| | InfluxDB | 8086 | Zeitreihen-Datenbank | | Telegraf | - | Metrik-Sammler | | Grafana | 3000 | Visualisierung |
Fazit
Grafana mit InfluxDB bietet ein flexibles und leistungsstarkes Monitoring-Setup. Telegraf sammelt automatisch System-Metriken, InfluxDB speichert sie effizient, und Grafana visualisiert sie in anpassbaren Dashboards. Beginnen Sie mit den Standard-Metriken und erweitern Sie nach Bedarf mit zusätzlichen Inputs und Alerts.
