Telegram-Benachrichtigungen (optional)

March 30, 2026 · View on GitHub

DockProbe

Leichtgewichtiges Docker-Monitoring-Dashboard mit Anomalieerkennung & Telegram-Benachrichtigungen
Ein Container. Ein Befehl. Volle Übersicht.

Docker Pulls Image Size

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

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:

# 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 — Multi-arch (amd64 + arm64)

Dashboard-Vorschau

DockProbe Dashboard

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 <name>` · `docker restart <name>` · `docker update --cpus=2 <name>`
Speicherüberlauf	`docker stats <name>` · `docker update --memory=2g <name>`
Neustart-Schleife	`docker logs --tail 50 <name>` · `docker inspect <name>`
Netzwerk-Spitze	`docker logs --tail 50 <name>` · 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:

# 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=80
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 install.sh   # Option 1 wählen

Zugriff über https://localhost:9090 oder https://<Ihre-IP>: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:

Port 9090 im Router auf die LAN-IP des Servers weiterleiten
Zugriff über https://<öffentliche-IP>:9090
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 install.sh   # Option 2 wählen, Tunnel-Token eingeben

Einrichtung:

Kostenloses Konto bei Cloudflare Zero Trust erstellen
Zu Networks > Tunnels > Create a tunnel navigieren
Tunnel benennen (z.B. dockprobe) und Tunnel-Token kopieren
bash install.sh ausführen und Cloudflare-Tunnel-Option wählen
Token eingeben
Im Cloudflare-Dashboard Public Hostname auf http://localhost:9090 setzen
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:

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

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.