alientimandClaude Sonnet 5
82bfeb17ed
- Neues, eigenständiges Frontend (Sidebar, zentriertes Logo in der Topbar, Dark/Light-Theme, Karten-Dashboard, Toasts/Modals statt Bootstrap) - Oeffentliches Kurz-Dashboard ohne Login (Status-Uebersicht) - Browser-SSH-Terminal (paramiko, plattformunabhaengig) zum Testen von Switch-Zugangsdaten inkl. interaktiver Host-Key-Bestaetigung - Granulares Rechtesystem mit Gruppen (Devices/Switches-Berechtigungen) - Aufgeraeumtes Backend mit konfigurierbaren Pfaden, auto-generierten Secrets statt hart codierter Werte im Original Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
198 lines
10 KiB
Markdown
198 lines
10 KiB
Markdown
# PoE Manager — Modern UI Rebuild
|
|
|
|
Webbasierte Verwaltung und Monitoring von PoE-Devices und Aruba-Switchen —
|
|
funktionales Rebuild von [Aruba-PoE](https://gitea.int.eertmoed.net/WiS/Aruba-PoE)
|
|
mit komplett neuem, modernem Frontend und einem granularen Rechtesystem.
|
|
|
|
**Das Projekt ist ausschließlich für Linux ausgelegt** (Zielsystem: eine
|
|
Linux-VM). Entwickelt wird unter WSL2 (Ubuntu) unter Windows — siehe
|
|
[Entwicklung unter WSL](#entwicklung-unter-wsl) weiter unten.
|
|
|
|
Die App ermöglicht:
|
|
|
|
- **Öffentliches Kurz-Dashboard ohne Login** (Hostname, IP, Status, letzte
|
|
Prüfung) — für den schnellen Blick auf dem Flur-Monitor; volle Verwaltung
|
|
und PoE-Neustart bleiben hinter dem Login
|
|
- Verwaltung von Devices und Switches (inkl. verschlüsselter SSH-Zugangsdaten)
|
|
- **Browser-SSH-Terminal beim Anlegen/Bearbeiten eines Switches**, um den
|
|
Host-Key zu bestätigen und die Zugangsdaten direkt zu prüfen, bevor der
|
|
Switch gespeichert wird — funktioniert auf jedem Betriebssystem, die
|
|
SSH-Verbindung wird dabei immer vom PoE-Server aus aufgebaut
|
|
- Manueller PoE-Neustart einzelner Geräte per Klick
|
|
- Einstellbares Prüfintervall (steuert den Hintergrund-Check-Dienst)
|
|
- Live-Log-Ansicht mit farblicher Hervorhebung (online/offline)
|
|
- **Rechtesystem mit Gruppen**: Admins dürfen immer alles; normalen
|
|
Benutzern lassen sich über Gruppen einzelne Verwaltungsrechte gezielt
|
|
zuweisen (siehe [Rechtesystem](#rechtesystem-gruppen--berechtigungen))
|
|
|
|
## Was ist neu gegenüber dem Original?
|
|
|
|
- **Komplett neues Frontend**: eigenes Design-System (kein Bootstrap mehr),
|
|
Logo mittig in der Topbar (auf jeder Seite, skaliert auf die Balkenhöhe),
|
|
Sidebar-Navigation (nur für eingeloggte Nutzer sichtbar), Dark/Light-
|
|
Umschalter, Karten-Dashboard mit Live-Zählern, moderne Modals/Toasts statt
|
|
Browser-`confirm()` und Bootstrap-Alerts.
|
|
- **Dashboard jetzt teilweise öffentlich**: `/` ist ohne Login erreichbar und
|
|
zeigt eine reduzierte Lese-Ansicht (Hostname, IP, Status, letzte Prüfung)
|
|
mit Login-Button; alle Verwaltungsseiten und der PoE-Neustart bleiben
|
|
`@login_required` und zusätzlich rechtebasiert (s.u.).
|
|
- **Browser-SSH-Terminal für Switche**, implementiert mit **paramiko** (reines
|
|
Python) statt eines lokalen pty + System-`ssh`-Client — läuft dadurch
|
|
plattformunabhängig. Die SSH-Verbindung zum Switch wird immer serverseitig
|
|
(vom PoE-Server) aufgebaut, nie vom Browser/Client aus.
|
|
- **Granulares Rechtesystem mit Gruppen** (neu, siehe unten) statt der
|
|
ursprünglichen reinen Admin/User-Unterscheidung.
|
|
- **Gleiche Kernlogik**: Datenbankschema (erweitert um Gruppen/Rechte),
|
|
Login, PoE-Restart-Mechanismus (`poe.sh` per SSH/`expect` auf die
|
|
Aruba-Switche) sind ansonsten unverändert.
|
|
- **Aufgeräumtes Backend**: konsistente, konfigurierbare Pfade (`POE_DB_PATH`,
|
|
`POE_SCRIPT`, `POE_LOG_GLOB`, …) statt hart codierter/inkonsistenter Pfade;
|
|
Secret-Key und Fernet-Key werden beim ersten Start automatisch generiert
|
|
statt im Repo zu liegen.
|
|
|
|
> ⚠️ **Sicherheitshinweis zum Original-Repo:** Im Original sind `sqlite.db`
|
|
> (Nutzer-Passwort-Hashes, verschlüsselte Switch-Passwörter) und `fernet.key`
|
|
> (der zugehörige Schlüssel) mit im Git-Repo eingecheckt — die `.gitignore`
|
|
> dort schließt sie über die `!`-Regeln versehentlich wieder ein. In diesem
|
|
> Rebuild sind beide Dateien in `.gitignore` ausgeschlossen und werden beim
|
|
> ersten Start frisch erzeugt. Empfehlung fürs Original-Repo: beide Dateien
|
|
> aus der Git-Historie entfernen und Fernet-Key sowie alle Switch-/User-
|
|
> Passwörter rotieren.
|
|
|
|
## Rechtesystem (Gruppen & Berechtigungen)
|
|
|
|
Admins (`is_admin=1`) dürfen wie bisher alles, inklusive Benutzer-/Gruppen-/
|
|
Settingsverwaltung — das bleibt exklusiv Admins vorbehalten. Zusätzlich gibt
|
|
es jetzt **Gruppen**: eine Gruppe bündelt einzelne Verwaltungsrechte, die
|
|
dann normalen Benutzern zugewiesen werden können, ohne sie zu Admins zu
|
|
machen. Ein Benutzer kann mehreren Gruppen angehören — die Rechte addieren
|
|
sich (Vereinigung, nicht Schnittmenge).
|
|
|
|
Verfügbare Rechte:
|
|
|
|
| Bereich | Recht | Bedeutung |
|
|
|----------|---------------------|---------------------------------------------|
|
|
| Devices | `devices.toggle` | Geräte aktivieren/deaktivieren |
|
|
| Devices | `devices.create` | Geräte anlegen |
|
|
| Devices | `devices.edit` | Geräte bearbeiten (inkl. Switch-Zuordnung) |
|
|
| Devices | `devices.delete` | Geräte löschen |
|
|
| Devices | `devices.restart` | PoE-Neustart über das Dashboard |
|
|
| Switches | `switches.create` | Switche anlegen |
|
|
| Switches | `switches.edit` | Switche bearbeiten |
|
|
| Switches | `switches.delete` | Switche löschen |
|
|
|
|
Verwaltet werden Gruppen unter **Gruppen** (nur für Admins sichtbar/nutzbar):
|
|
Name vergeben, Rechte per Checkbox zuweisen, Mitglieder auswählen. Die
|
|
Devices-Seite bleibt für alle eingeloggten Benutzer les- und durchsuchbar;
|
|
nur die tatsächlichen Aktionen (Buttons, Toggle-Switches, Formulare) sind an
|
|
das jeweilige Recht gekoppelt — sowohl im Frontend (ausgeblendet) als auch
|
|
im Backend (serverseitig durchgesetzt, unabhängig vom Frontend). Die
|
|
Switches-Seite ist komplett unsichtbar/gesperrt für Benutzer ohne mindestens
|
|
ein `switches.*`-Recht.
|
|
|
|
Datenmodell: `groups`, `group_permissions` (Gruppe → Recht), `user_groups`
|
|
(Benutzer → Gruppe). Bestehende Datenbanken werden beim App-Start automatisch
|
|
um diese Tabellen ergänzt (`_ensure_schema()` in `app.py`), ein manuelles
|
|
Migrations-Skript ist nicht nötig.
|
|
|
|
## Entwicklung unter WSL
|
|
|
|
Da das Projekt ausschließlich für Linux gebaut ist, empfiehlt sich die
|
|
Entwicklung direkt unter WSL2 (Ubuntu), auch wenn der Editor unter Windows
|
|
läuft — das Projektverzeichnis liegt dabei ganz normal unter
|
|
`C:\...\aruba-poe-modern` und wird aus WSL über `/mnt/c/...` erreicht:
|
|
|
|
```bash
|
|
wsl --install -d Ubuntu # einmalig, falls noch nicht vorhanden
|
|
wsl -d Ubuntu
|
|
sudo apt update && sudo apt install -y python3 python3-venv python3-pip sqlite3 expect openssh-client
|
|
cd /mnt/c/Users/<dich>/aruba-poe-modern/srv/poe_manager
|
|
python3 -m venv venv
|
|
./venv/bin/pip install -r requirements.txt
|
|
./venv/bin/python create_db.py
|
|
./venv/bin/python create_admin.py
|
|
./venv/bin/python app.py # http://localhost:5000 — via WSL2-Portweiterleitung
|
|
# auch aus dem Windows-Browser erreichbar
|
|
```
|
|
|
|
## Lokal starten (Entwicklung)
|
|
|
|
```bash
|
|
cd srv/poe_manager
|
|
python3 -m venv venv
|
|
source venv/bin/activate
|
|
pip install -r requirements.txt
|
|
|
|
python create_db.py # legt sqlite.db + Tabellen an
|
|
python create_admin.py # legt ersten Admin-Benutzer an
|
|
|
|
python app.py # http://localhost:5000
|
|
```
|
|
|
|
## Produktiv-Deployment (auf der Ziel-VM, unter `/srv/poe_manager`)
|
|
|
|
```bash
|
|
sudo git clone <dieses-repo> /srv/poe_manager
|
|
cd /srv/poe_manager
|
|
sudo bash install.sh
|
|
sudo /srv/poe_manager/venv/bin/python3 /srv/poe_manager/create_admin.py
|
|
```
|
|
|
|
`install.sh` installiert Systempakete, richtet die venv ein, initialisiert die
|
|
Datenbank (falls nicht vorhanden), kopiert `poe.sh` nach
|
|
`/usr/local/bin/custom/`, registriert die systemd-Units
|
|
(`poe_web.service`, `rpi-check.service`, `rpi-check-restart.timer`) und
|
|
konfiguriert nginx als Reverse-Proxy auf Port 80.
|
|
|
|
### Relevante Umgebungsvariablen (optional)
|
|
|
|
| Variable | Zweck | Default |
|
|
|-----------------------|------------------------------------------|---------------------------------------|
|
|
| `POE_DB_PATH` | Pfad zur SQLite-DB | `<app-dir>/sqlite.db` |
|
|
| `POE_SCRIPT` | Pfad zum PoE-Restart-Skript | `/usr/local/bin/custom/poe.sh` |
|
|
| `POE_LOG_GLOB` | Glob-Pattern der Check-Logs | `/var/log/rpi-*.log` |
|
|
| `POE_FERNET_KEY` | Pfad zum Fernet-Schlüssel | `<app-dir>/fernet.key` (auto-erzeugt)|
|
|
| `POE_KNOWN_HOSTS` | Pfad zur SSH-known_hosts-Datei des Terminals| `<app-dir>/known_hosts` (auto-erzeugt)|
|
|
| `POE_SECRET_KEY` | Flask Secret Key (überschreibt Datei) | zufällig, in `secret.key` gespeichert|
|
|
| `PORT`, `FLASK_DEBUG` | Flask-Serverport / Debug-Modus | `5000` / aus |
|
|
|
|
## Browser-SSH-Terminal (Switch-Verbindungstest)
|
|
|
|
„Verbindung testen“ im Switch-Modal öffnet eine WebSocket-Verbindung zu
|
|
`/ws/ssh_terminal`. Serverseitig baut **paramiko** eine echte SSH-Sitzung
|
|
zum Switch auf (inkl. interaktiver Host-Key-Bestätigung beim Erstkontakt,
|
|
danach dauerhaft in `known_hosts` gemerkt) und reicht eine interaktive Shell
|
|
1:1 an ein xterm.js-Terminal im Browser durch. Die Zugangsdaten aus dem
|
|
Formular werden direkt für die SSH-Authentifizierung verwendet (nicht als
|
|
Tastatureingabe in die Shell getippt) — Erfolg/Fehlschlag der Anmeldung wird
|
|
sofort und eindeutig im Terminal angezeigt. Ein Klick auf „Passwort
|
|
einfügen“ sendet den aktuell im Formular eingetragenen Wert zusätzlich als
|
|
Tastatureingabe (z.B. für ein `sudo`-Passwort in der geöffneten Sitzung).
|
|
|
|
Voraussetzungen:
|
|
- Läuft auf **jedem Betriebssystem** (paramiko ist reines Python) — die
|
|
SSH-Verbindung wird dabei immer vom PoE-Server aus aufgebaut, nie vom
|
|
Browser/Client.
|
|
- Nur für eingeloggte **Admins** erreichbar.
|
|
- Der Flask-Entwicklungsserver muss mit `threaded=True` laufen (ist bereits
|
|
so konfiguriert) — für einen echten Produktivbetrieb empfiehlt sich
|
|
ohnehin ein WSGI-Server mit WebSocket-Unterstützung (z.B. Gunicorn mit
|
|
`gevent`- oder `eventlet`-Worker) statt des eingebauten Dev-Servers.
|
|
- Da `poe_web.service` (wie im Original) als `root` läuft, kann über dieses
|
|
Terminal im Prinzip jeder erreichbare Host per SSH kontaktiert werden —
|
|
bewusst so gewählt, da Admins über die App ohnehin schon vollen Zugriff auf
|
|
alle hinterlegten Switch-Zugangsdaten haben. Für eine strengere Trennung
|
|
empfiehlt es sich, `poe_web.service` künftig unter einem eigenen,
|
|
unprivilegierten Systembenutzer laufen zu lassen (im Original wie auch hier
|
|
aktuell `root`, um Änderungen am produktiven Setup nicht zu vergrößern).
|
|
|
|
## Projektstruktur
|
|
|
|
```
|
|
srv/poe_manager/ Flask-App (Backend + Templates + Static-Assets)
|
|
usr/local/bin/custom/ poe.sh — Ping-Check & PoE-Restart per SSH (expect)
|
|
etc/systemd/system/ Service-/Timer-Units (Web-App + Check-Dienst)
|
|
etc/nginx/ Reverse-Proxy-Konfiguration
|
|
install.sh Produktiv-Installer
|
|
```
|