DockProbe
Leichtgewichtiges Docker-Monitoring-Dashboard mit Anomalieerkennung & Telegram-Benachrichtigungen
Ein Container. Ein Befehl. Volle Übersicht.
English | 한국어 | 日本語 | Deutsch | Français | Español | Português | Italiano
---
## Was ist DockProbe?
DockProbe ist ein selbst gehostetes Docker-Monitoring-Dashboard, das als einzelner Container läuft. Es sammelt in Echtzeit CPU-, Speicher-, Netzwerk- und Festplattenmetriken von allen Containern und dem Host-System — und zeigt alles in einer übersichtlichen, dunklen Web-Oberfläche an.
**GPU-fähiges Host-Monitoring** verfolgt NVIDIA-GPU-Temperatur und -Auslastung zusammen mit CPU-Nutzung, Host-Speicher, Festplattenengpässen und Lastdurchschnitt — alles in Echtzeit-Diagrammen. Wenn Sie ML-Workloads oder GPU-intensive Container betreiben, bietet DockProbe volle Transparenz ohne separate GPU-Monitoring-Tools.
Wenn etwas schiefgeht, erkennt DockProbe es automatisch. Sechs integrierte Anomalieerkennungsregeln überwachen CPU-Spitzen, Speicherüberläufe, Temperaturwarnungen, Festplattenengpässe, unerwartete Neustarts und Netzwerkanstiege. Jeder Alarm enthält **empfohlene Maßnahmen mit sofort ausführbaren Befehlen** — so wissen Sie nicht nur, was schiefgelaufen ist, sondern auch genau, was zu tun ist. Alarme werden sofort per Telegram gesendet, damit Sie reagieren können, bevor Nutzer es bemerken.
Ein integrierter Sicherheitsscanner führt alle 5 Minuten 16 automatisierte Prüfungen durch — zu Container-Fehlkonfigurationen, Netzwerk-Exposition und Host-Härtung — damit Sie Schwachstellen erkennen, bevor sie zu Vorfällen werden.
Kein Agent muss auf jedem Container installiert werden, keine externe Datenbank, keine komplexe Konfiguration. Einfach den Docker-Socket einbinden, einen Befehl ausführen, und Sie haben unter `https://localhost:9090` volle Übersicht über Ihre Docker-Umgebung. Zugriff von außerhalb Ihres Netzwerks? Die integrierte Cloudflare-Tunnel-Unterstützung bietet sicheres öffentliches HTTPS ohne Portweiterleitung.
---
## Schnellstart
```bash
git clone https://github.com/deep-on/dockprobe.git && cd dockprobe && bash install.sh
```
Das war's. Der interaktive Installer konfiguriert Authentifizierung, Telegram-Benachrichtigungen und HTTPS — und öffnet dann `https://localhost:9090`.
> **Voraussetzungen:** Docker (mit Compose v2), Git, OpenSSL
---
## Direkt von Docker Hub starten
Kein git clone, kein Build — einfach pullen und starten:
```bash
# 1. Compose-Datei und Umgebungsvariablen-Vorlage herunterladen
curl -fsSL https://raw.githubusercontent.com/deep-on/dockprobe/main/docker-compose.hub.yaml -o docker-compose.yaml
curl -fsSL https://raw.githubusercontent.com/deep-on/dockprobe/main/.env.example -o .env
# 2. .env mit Ihren Zugangsdaten bearbeiten
vi .env
# 3. (Optional) Selbstsigniertes SSL-Zertifikat erstellen
mkdir -p certs && openssl req -x509 -newkey rsa:4096 -nodes \
-keyout certs/key.pem -out certs/cert.pem \
-days 825 -subj "/CN=dockprobe"
# 4. Starten
docker compose up -d
```
> **Verfügbar auf Docker Hub:** [`deeponinc/dockprobe`](https://hub.docker.com/r/deeponinc/dockprobe) — Multi-arch (amd64 + arm64)
---
## Dashboard-Vorschau
---
## Funktionen
| Kategorie | Was Sie erhalten |
|-----------|-----------------|
| **Echtzeit-Dashboard** | Dunkles Web-UI, 10s Auto-Aktualisierung, sortierbare Tabellen, Chart.js-Diagramme |
| **Container-Monitoring** | CPU %, Speicher %, Netzwerk-I/O, Block-I/O, Neustart-Zähler |
| **Host-Monitoring** | CPU/GPU-Temperatur & -Auslastung, Arbeitsspeicher, Festplattennutzung, Lastdurchschnitt |
| **Anomalieerkennung** | 6 Regeln mit empfohlenen Maßnahmen — CPU-Spitze, Speicherüberlauf, Hochtemperatur, Festplatte voll, Neustart, Netzwerk-Spitze |
| **Telegram-Benachrichtigungen** | Sofortige Benachrichtigung mit 30-Min-Cooldown pro Alarmtyp |
| **Sicherheit** | Basic Auth, Ratenlimitierung (5 Fehlversuche = 60s Sperre), HTTPS |
| **Sicherheitsscanner** | 16 automatisierte Prüfungen (Container/Host/Netzwerk), 5-Min-Scan-Zyklus, Schweregrad-Badges |
| **Sitzungsverwaltung** | Aktive Verbindungsverfolgung, konfigurierbare Max-Verbindungen, Live-IP-Anzeige |
| **Passwortverwaltung** | Benutzername/Passwort über Dashboard-UI ändern |
| **Einstellungs-UI** | Max-Verbindungen zur Laufzeit über das Dashboard anpassen |
| **Zugriffsmodi** | Selbstsigniertes SSL (Standard) oder Cloudflare Tunnel (kein Port-Forwarding) |
| **Leichtgewichtig** | 4 Python-Pakete, einzelne HTML-Datei, SQLite mit 7-Tage-Aufbewahrung |
---
## Dashboard-Aufbau
| Bereich | Details |
|---------|---------|
| Sitzungsleiste | Angemeldeter Benutzer, IP, aktive Verbindungen / Max-Limit |
| Host-Karten | CPU-Temp, GPU-Temp, CPU/GPU %, Host-Speicher, Festplatte %, Lastdurchschnitt |
| Container-Tabelle | Sortierbar nach CPU/Speicher/Netzwerk, farbcodierte Anomalien |
| Diagramme (5) | Container-CPU- & Speicher-Trends, Host-CPU/GPU %, Host-Temperatur & Last |
| Docker-Festplatte | Images, Build-Cache, Volumes, Container-RW-Schichten |
| Alarm-Verlauf | Letzte 24h mit Zeitstempeln |
---
## Anomalieerkennungsregeln
| Regel | Bedingung | Aktion |
|-------|-----------|--------|
| Container-CPU | >80% für 3 aufeinanderfolgende Prüfungen (30s) | Telegram + rote Hervorhebung |
| Container-Speicher | >90% des Limits | Sofortiger Alarm |
| Host-CPU-Temperatur | >85°C | Sofortiger Alarm |
| Host-Festplatte | >90% Nutzung | Sofortiger Alarm |
| Container-Neustart | restart_count erhöht | Sofortiger Alarm |
| Netzwerk-Spitze | RX 10-facher Anstieg + >100MB | Sofortiger Alarm |
Alle Schwellenwerte sind über Umgebungsvariablen konfigurierbar.
Jede Anomalie enthält **umsetzbare Empfehlungen** mit konkreten Befehlen:
| Anomalie | Beispiel-Empfehlung |
|----------|-------------------|
| CPU-Spitze | `docker stats ` · `docker restart ` · `docker update --cpus=2 ` |
| Speicherüberlauf | `docker stats ` · `docker update --memory=2g ` |
| Neustart-Schleife | `docker logs --tail 50 ` · `docker inspect ` |
| Netzwerk-Spitze | `docker logs --tail 50 ` · Auf DDoS oder unerwarteten Datenverkehr prüfen |
| Hohe Temperatur | Lüfter-/Kühlsystem prüfen · `sensors -u` für Details |
| Festplatte voll | `docker system prune -f` · `docker builder prune -f` · `docker volume prune` |
---
## Sicherheitsscanner
DockProbe führt alle 5 Minuten 16 automatisierte Sicherheitsprüfungen durch und zeigt die Ergebnisse in einem dedizierten Dashboard-Bereich mit Schweregrad-Badges an.
| Kategorie | Prüfungen |
|-----------|-----------|
| **Container** (9) | Privilegierter Modus, Ausführung als Root, gefährliche Capabilities, Docker-Socket-Mount, sensible Pfad-Mounts, Nur-Lese-Rootfs, AppArmor/Seccomp deaktiviert, Geheimnisse in Umgebungsvariablen, keine Speicher-/CPU-Limits |
| **Netzwerk** (3) | Host-Netzwerkmodus, übermäßige Port-Exposition, SSH-Port (22) freigegeben |
| **Host** (4) | Docker-Daemon-Sicherheitsoptionen, Kernel-ASLR, IP-Weiterleitung, Linux Security Module Status |
**Schweregrade:**
- 🔴 **Kritisch** — Sofortiges Handeln erforderlich (z.B. privilegierter Modus, beschreibbarer Docker-Socket)
- 🟡 **Warnung** — Sicherheitsverbesserung empfohlen
- 🔵 **Info** — Informative Befunde
- 🟣 **Nicht verfügbar** — Prüfung kann aufgrund von Umgebungseinschränkungen nicht ausgeführt werden; zeigt Aktivierungsanleitung
> Host-Prüfungen erfordern Volume-Mounts (`/proc:/host_proc:ro`, `/sys:/host_sys:ro`). Ohne diese Mounts werden die betroffenen Prüfungen als **Nicht verfügbar** mit Einrichtungsanleitung angezeigt.
---
## Architektur
```
┌──────────────────────────────────────────────┐
│ DockProbe Container │
│ │
│ FastAPI + uvicorn (Port 9090) │
│ ├── collectors/ │
│ │ ├── containers.py (aiodocker) │
│ │ ├── host.py (/proc, /sys, GPU) │
│ │ └── images.py (system df) │
│ ├── alerting/ │
│ │ ├── detector.py (6 Regeln + Aktionen) │
│ │ └── telegram.py (httpx) │
│ ├── security/ │
│ │ └── scanner.py (16 checks) │
│ ├── storage/ │
│ │ └── db.py (SQLite WAL) │
│ └── static/ │
│ └── index.html (Chart.js) │
│ │
│ Volumes: │
│ docker.sock (ro), /sys (ro), /proc (ro), │
│ nvidia-smi (ro), SQLite Named Volume │
└──────────────────────────────────────────────┘
```
**Abhängigkeiten (nur 4 Pakete):**
- `fastapi` — Web-Framework
- `uvicorn` — ASGI-Server
- `aiodocker` — Asynchroner Docker-API-Client
- `httpx` — Asynchroner HTTP-Client (Telegram-API)
---
## Konfiguration
Alle Einstellungen über `.env`-Datei:
```env
# Authentifizierung (erforderlich)
AUTH_USER=admin
AUTH_PASS=your-password
# Telegram-Benachrichtigungen (optional)
TELEGRAM_BOT_TOKEN=your-bot-token
TELEGRAM_CHAT_ID=your-chat-id
# Schwellenwerte (optional, Standardwerte angezeigt)
# CPU_THRESHOLD: ohne Angabe skaliert er mit der Maschine (80 × Kerne; 100% = ein Kern)
MEM_THRESHOLD=90
# Verbindungslimit (optional, 0 = unbegrenzt)
MAX_CONNECTIONS=3
# Cloudflare Tunnel (optional)
CF_TUNNEL_TOKEN=your-tunnel-token
```
---
## Zugriffsmodi
### Option 1: Lokales Netzwerk (selbstsigniertes SSL) — Standard
```bash
bash install.sh # Option 1 wählen
```
Zugriff über `https://localhost:9090` oder `https://:9090`
Für den Zugriff von anderen Geräten im selben Netzwerk verwenden Sie die LAN-IP des Servers (z.B. `https://192.168.1.100:9090`). Bei Bedarf:
- Port in der Firewall freigeben: `sudo ufw allow 9090/tcp`
- Selbstsignierte Zertifikatswarnung im Browser akzeptieren
> **Warum die Browser-Warnung?** DockProbe verwendet ein bei der Installation generiertes selbstsigniertes SSL-Zertifikat. Da es nicht von einer vertrauenswürdigen Zertifizierungsstelle (CA) ausgestellt wurde, zeigt der Browser eine "Ihre Verbindung ist nicht privat"-Warnung. Dies ist normal — klicken Sie auf "Erweitert" → "Weiter zur Seite". Um diese Warnung zu vermeiden, verwenden Sie Cloudflare Tunnel (Option 3), der automatisch ein vertrauenswürdiges TLS-Zertifikat bereitstellt.
### Option 2: Fernzugriff per Portweiterleitung
Für externen Zugriff ohne Cloudflare:
1. Port 9090 im Router auf die LAN-IP des Servers weiterleiten
2. Zugriff über `https://<öffentliche-IP>:9090`
3. Bei wechselnder öffentlicher IP einen DDNS-Dienst (No-IP, DuckDNS etc.) verwenden
> **Hinweis:** Der Port wird direkt exponiert. Basic Auth + HTTPS sind standardmäßig aktiv, aber für mehr Sicherheit wird Cloudflare Tunnel (Option 3) empfohlen.
### Option 3: Cloudflare Tunnel (empfohlen für Fernzugriff)
Keine Portweiterleitung, keine Firewall-Änderungen, gültiges TLS-Zertifikat — der einfachste und sicherste Weg für den Zugriff von überall.
```bash
bash install.sh # Option 2 wählen, Tunnel-Token eingeben
```
**Einrichtung:**
1. Kostenloses Konto bei [Cloudflare Zero Trust](https://one.dash.cloudflare.com) erstellen
2. Zu **Networks** > **Tunnels** > **Create a tunnel** navigieren
3. Tunnel benennen (z.B. `dockprobe`) und Tunnel-Token kopieren
4. `bash install.sh` ausführen und Cloudflare-Tunnel-Option wählen
5. Token eingeben
6. Im Cloudflare-Dashboard **Public Hostname** auf `http://localhost:9090` setzen
7. Zugriff über `https://your-domain.com` mit gültigem TLS-Zertifikat
---
## API-Endpunkte
| Endpunkt | Methode | Beschreibung |
|----------|---------|-------------|
| `/` | GET | Dashboard-HTML |
| `/api/current` | GET | Neuester Snapshot (Container + Host + Images + Anomalien) |
| `/api/history/{name}?hours=1` | GET | Container-Zeitreihen |
| `/api/history/host?hours=1` | GET | Host-Zeitreihen |
| `/api/alerts?hours=24` | GET | Alarm-Verlauf |
| `/api/session` | GET | Aktueller Benutzer, IP, aktive Verbindungen |
| `/api/settings` | GET/POST | Laufzeiteinstellungen (max_connections) |
| `/api/change-password` | POST | Benutzername/Passwort ändern |
| `/api/health` | GET | Gesundheitsprüfung (keine Authentifizierung erforderlich) |
---
## Sicherheit
DockProbe ist für sicheres Self-Hosting mit mehreren Schutzebenen konzipiert:
**Authentifizierung & Zugriff**
- **Basic Auth** auf allen Endpunkten (außer `/api/health`)
- **PBKDF2-SHA256** Passwort-Hashing mit zufälligem Salt (600k Iterationen)
- **Ratenlimitierung** — 5 fehlgeschlagene Anmeldeversuche → 60s Sperre pro IP
- **Mindestens 8 Zeichen** Passwortanforderung
- **Verbindungslimit** — Konfigurierbare maximale gleichzeitige Benutzer
**Netzwerk & Transport**
- **HTTPS** — Selbstsigniertes RSA-4096 (Standard) oder Cloudflare Tunnel
- **CORS** — Cross-Origin-Anfragen explizit blockiert
- **CSRF-Schutz** — POST-Endpunkte erfordern `X-Requested-With`-Header
- **HTTP-Fallback-Warnung** — Klartextmodus warnt beim Start (nur Tunnel)
**Container-Härtung**
- **Nicht-Root** — Container läuft als `appuser`, nicht als root
- **Nur-Lese-Mounts** — Docker-Socket, /sys, /proc alle read-only eingebunden
- **Pfad-Traversal-Schutz** — Statische Dateiauslieferung validiert aufgelöste Pfade
- **Kein Schreibzugriff** — Nur Monitoring, keine Container-Steuerung
- **Kein OpenAPI/Swagger** — API-Dokumentationsendpunkte in der Produktion deaktiviert
**Proxy-bewusstes Ratenlimit**
- `X-Forwarded-For` wird nur von IPs vertraut, die in der Umgebungsvariable `TRUSTED_PROXIES` aufgeführt sind
- Direkte Verbindungen verwenden immer die echte Client-IP
---
## Manuelle Einrichtung
Falls Sie die manuelle Konfiguration bevorzugen:
```bash
git clone https://github.com/deep-on/dockprobe.git
cd dockprobe
# .env erstellen
cp .env.example .env
vi .env
# SSL-Zertifikat generieren (optional)
mkdir -p certs
openssl req -x509 -newkey rsa:2048 -nodes \
-keyout certs/key.pem -out certs/cert.pem \
-days 365 -subj "/CN=dockprobe"
# Starten
docker compose up -d --build
```
---
## Lizenz
Apache License 2.0 — siehe [LICENSE](LICENSE)
**Namensnennung:** Modifizierte oder weiterverteilte Versionen müssen das DeepOn-Logo und den Hinweis „Powered by DeepOn Inc." in der Benutzeroberfläche beibehalten.
---
Entwickelt von DeepOn Inc.