Skip to content

README.de.md

Latest commit

 

History

History
351 lines (256 loc) · 15.5 KB

README.de.md

File metadata and controls

351 lines (256 loc) · 15.5 KB

DockProbe

DockProbe

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

English | 한국어 | 日本語 | Deutsch | Français | Español | Português | Italiano

License Python Docker Deps 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:

  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 install.sh   # Option 2 wählen, Tunnel-Token eingeben

Einrichtung:

  1. Kostenloses Konto bei Cloudflare Zero Trust 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:

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.

DeepOn Entwickelt von DeepOn Inc.