core/Projektarbeit-MYP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ich geh behindert

Browse Source
This commit is contained in:
Till Tomczak
2025-06-05 01:34:10 +02:00
parent 0ae23e5272
commit 375c48d72f
478 changed files with 11113 additions and 231267 deletions
Download Patch File Download Diff File Expand all files Collapse all files

418
docs/KIOSK-SETUP.md
View File

@@ -7,240 +7,278 @@ Diese Anleitung beschreibt, wie MYP (Manage Your Printer) auf einem Raspberry Pi
- Raspberry Pi 4 (oder kompatibel) mit Raspbian/Raspberry Pi OS
- Internetverbindung für die Installation (nach der Installation wird keine Verbindung mehr benötigt)
- Bildschirm, Tastatur und Maus für die Einrichtung
- Mindestens 2GB freier Festplattenplatz
- Mindestens 512MB RAM (empfohlen: 1GB+)
## Komponenten des Kiosk-Modus
Die Kiosk-Einrichtung besteht aus mehreren Komponenten:
1. **Flask-Backend-Dienst**: Systemd-Service zum Starten der MYP-Anwendung
2. **Chromium im Kiosk-Modus**: Browserinstanz, die das Dashboard anzeigt
3. **Watchdog**: Überwacht den Browser und das Backend, startet bei Bedarf neu
1. **MYP HTTPS-Backend-Dienst**: Systemd-Service zum Starten der MYP-Anwendung auf Port 5000
2. **Kiosk-Benutzer**: Separater Benutzer für den Browser-Betrieb
3. **Chromium im Kiosk-Modus**: Optimierte Browserinstanz mit erweiterten Kiosk-Features
4. **Watchdog-Services**: Mehrere Überwachungsdienste für Backend und Browser
5. **Firewall-Service**: Automatische Netzwerksicherheit
## Automatische Installation
## Automatische Installation (Empfohlen)
Für die automatische Installation kann das mitgelieferte Setup-Script verwendet werden:
Die automatische Installation erfolgt über das konsolidierte Setup-Script im Backend-Verzeichnis:
```bash
chmod +x setup.sh
./setup.sh
cd backend
sudo chmod +x setup.sh
sudo ./setup.sh
```
Dieses Script führt alle notwendigen Schritte aus:
- Installation der benötigten Pakete
- Kopieren der MYP-Anwendung nach `/opt/myp`
- Einrichtung der Python-Umgebung und Installation der Abhängigkeiten
- Konfiguration der Systemd-Dienste
- Einrichtung des Kiosk-Modus
- Einrichtung des Watchdogs
Das Setup-Script bietet folgende Features:
- **Robuste Installation** mit Retry-Mechanismen
- **Umfangreiches Logging** in `backend/logs/`
- **System-Validierung** vor Installation
- **Automatische Abhängigkeitsauflösung**
- **Konfiguration aller Services**
- **Firewall-Setup**
- **Automatischer Kiosk-Benutzer**
Nach der Ausführung des Scripts muss noch der automatische Login aktiviert werden:
```bash
sudo raspi-config
# 1 System Options → S5 Boot/Auto Login → B4 Desktop Autologin
```
### Installation-Logs
## Manuelle Installation
Das Setup-Script erstellt detaillierte Logs:
- `backend/logs/install.log` - Vollständiges Installations-Log
- `backend/logs/errors.log` - Nur Fehler
- `backend/logs/warnings.log` - Nur Warnungen
- `backend/logs/debug.log` - Debug-Informationen
- `backend/logs/install-summary.txt` - Zusammenfassung
Falls eine manuelle Installation bevorzugt wird, können die folgenden Schritte ausgeführt werden:
## Systemd-Services (Automatisch installiert)
### 1. Pakete installieren
```bash
sudo apt update
sudo apt install -y python3 python3-pip python3-venv chromium-browser \
unclutter xdotool xscreensaver git
```
### 2. MYP nach /opt/myp kopieren
```bash
sudo mkdir -p /opt/myp
sudo chown $USER:$USER /opt/myp
cp -r ./myp/* /opt/myp
cd /opt/myp
```
### 3. Python-Umgebung und Abhängigkeiten einrichten
```bash
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
```
### 4. Systemd-Dienst für das Flask-Backend
Datei erstellen: `/etc/systemd/system/myp.service`
Das Setup-Script installiert folgende Services:
### 1. MYP HTTPS-Backend (`myp-https.service`)
```ini
[Unit]
Description=MYP Flask Backend
Description=MYP Druckerverwaltung HTTP Backend (Port 5000)
After=network-online.target
Wants=network-online.target
[Service]
User=pi
Type=simple
User=root
WorkingDirectory=/opt/myp
ExecStart=/opt/myp/.venv/bin/python /opt/myp/app.py
ExecStart=/usr/bin/python3 /opt/myp/app.py --production
Restart=always
Environment=PYTHONUNBUFFERED=1
Environment=FLASK_ENV=production
Environment=FLASK_PORT=5000
Environment=KIOSK_MODE=true
[Install]
WantedBy=multi-user.target
```
Dienst aktivieren:
### 2. Kiosk-Browser (`myp-kiosk.service`)
- Startet Chromium im optimierten Kiosk-Modus
- Wartet automatisch auf Backend-Verfügbarkeit
- Umfangreiche Browser-Optimierungen
- Automatischer Neustart bei Fehlern
### 3. Watchdog-Services
- `kiosk-watchdog.service` - Überwacht Browser und Backend
- `kiosk-watchdog-python.service` - Python-basierte Überwachung
### 4. Firewall-Service (`myp-firewall.service`)
- Automatische Netzwerksicherheit
- Port-Management
## Manuelle Installation (Nur bei Bedarf)
Falls die automatische Installation nicht verwendet werden kann:
### 1. Pakete installieren
```bash
sudo apt update
sudo apt install -y python3 python3-pip python3-venv chromium-browser \
unclutter xdotool curl git
```
### 2. MYP-Backend nach /opt/myp kopieren
```bash
sudo mkdir -p /opt/myp
sudo cp -r ./backend/* /opt/myp/
cd /opt/myp
sudo pip3 install -r requirements.txt --break-system-packages
```
### 3. Kiosk-Benutzer erstellen
```bash
sudo useradd -m -s /bin/bash kiosk
sudo usermod -a -G video,audio kiosk
```
### 4. Systemd-Services installieren
```bash
sudo cp /opt/myp/systemd/*.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable --now myp.service
sudo systemctl enable myp-https.service
sudo systemctl enable myp-kiosk.service
sudo systemctl enable kiosk-watchdog.service
sudo systemctl enable myp-firewall.service
```
### 5. Kiosk-Script einrichten
Datei erstellen: `/home/pi/kiosk.sh`
```bash
#!/usr/bin/env bash
# Bildschirm-Blanking verhindern
xset s off
xset s noblank
xset -dpms
# Mauszeiger ausblenden
unclutter -idle 0.5 -root &
# Chromium-Crash-Dialoge unterdrücken
sed -i 's/"exited_cleanly":false/"exited_cleanly":true/' \
"$HOME/.config/chromium/Default/Preferences" 2>/dev/null || true
sed -i 's/"exit_type":"Crashed"/"exit_type":"Normal"/' \
"$HOME/.config/chromium/Default/Preferences" 2>/dev/null || true
# Browser starten
chromium-browser --kiosk --noerrdialogs --disable-infobars \
--window-position=0,0 --app=http://localhost:5000/ &
```
Ausführbar machen:
```bash
chmod +x /home/pi/kiosk.sh
```
### 6. Systemd-User-Dienst für den Browser
Verzeichnis erstellen:
```bash
mkdir -p /home/pi/.config/systemd/user
```
Datei erstellen: `/home/pi/.config/systemd/user/kiosk.service`
```ini
[Unit]
Description=Chromium Kiosk
PartOf=graphical-session.target
[Service]
Type=forking
ExecStart=/home/pi/kiosk.sh
Restart=on-abort
[Install]
WantedBy=xsession.target
```
Dienst aktivieren:
```bash
systemctl --user daemon-reload
systemctl --user enable kiosk.service
sudo loginctl enable-linger pi
```
### 7. Watchdog einrichten
Datei erstellen: `/home/pi/watchdog.sh`
```bash
#!/usr/bin/env bash
# MYP Watchdog für Chromium Browser
# Funktion zum Loggen von Nachrichten
log() {
echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> /home/pi/myp-watchdog.log
}
# Prüfen, ob Chromium läuft
if ! pgrep -x "chromium-browse" > /dev/null; then
log "Chromium nicht gefunden - starte neu"
# Alle eventuell noch vorhandenen Chromium-Prozesse beenden
pkill -f chromium || true
# Warten bis alle Prozesse beendet sind
sleep 2
# Kiosk-Script neu starten
/home/pi/kiosk.sh
log "Chromium neugestartet"
fi
# Prüfen, ob MYP Flask-Dienst läuft
if ! systemctl is-active --quiet myp.service; then
log "MYP Flask-Dienst ist nicht aktiv - starte neu"
# Dienst neustarten
sudo systemctl restart myp.service
log "MYP Flask-Dienst neugestartet"
fi
exit 0
```
Ausführbar machen und Cron-Job einrichten:
```bash
chmod +x /home/pi/watchdog.sh
(crontab -l 2>/dev/null || echo "") | grep -v "watchdog.sh" | { cat; echo "*/5 * * * * /home/pi/watchdog.sh > /dev/null 2>&1"; } | crontab -
```
### 8. Automatischen Desktop-Login einschalten
### 5. Automatischen Desktop-Login einschalten
```bash
sudo raspi-config
# 1 System Options → S5 Boot/Auto Login → B4 Desktop Autologin
```
### 9. Bildschirm nie ausschalten
```bash
sudo sed -i 's/#BLANK_TIME=.*/BLANK_TIME=0/' /etc/xdg/lxsession/LXDE-pi/autostart
```
## Ablauf beim Booten
1. Der Raspberry Pi startet und fährt bis zum Multi-User-Target hoch
2. `myp.service` wird gestartet und das Flask-Backend sowie der Plug-Scheduler laufen
3. LightDM startet und meldet den Benutzer `pi` automatisch an
4. Nach dem Anmelden wird der User-Scope geladen und `kiosk.service` gestartet
5. `kiosk.sh` startet Chromium im Kiosk-Modus und öffnet die MYP-Oberfläche
6. Der Watchdog-Cron-Job überwacht alle 5 Minuten, ob alles läuft
1. **System-Start**: Raspberry Pi fährt bis zum Multi-User-Target hoch
2. **Backend-Start**: `myp-https.service` startet das Flask-Backend auf Port 5000
3. **Firewall-Start**: `myp-firewall.service` konfiguriert Netzwerksicherheit
4. **Desktop-Login**: LightDM startet und meldet den Benutzer automatisch an
5. **Kiosk-Start**: `myp-kiosk.service` wartet auf Backend und startet Chromium
6. **Watchdog-Aktivierung**: Überwachungsservices starten kontinuierliche Überwachung
## Browser-Optimierungen
Der Kiosk-Service startet Chromium mit umfangreichen Optimierungen:
### Performance-Optimierungen
- `--disable-gpu-sandbox`
- `--disable-software-rasterizer`
- `--enable-features=VaapiVideoDecoder`
- `--memory-pressure-off`
- `--max_old_space_size=512`
### Kiosk-spezifische Features
- `--kiosk` (Vollbild-Modus)
- `--hide-scrollbars`
- `--disable-pinch`
- `--no-first-run`
- `--autoplay-policy=no-user-gesture-required`
### Sicherheits-Anpassungen
- `--ignore-certificate-errors`
- `--disable-web-security` (für lokale Anwendung)
- `--no-sandbox`
## Fehlerbehebung
- **MYP startet nicht**: `systemctl status myp.service` zeigt den Status des Dienstes
- **Browser startet nicht**: `systemctl --user status kiosk.service` zeigt den Status des Kiosk-Dienstes
- **Watchdog-Logs**: In `/home/pi/myp-watchdog.log` werden Probleme und Neustarts protokolliert
### Service-Status prüfen
```bash
# Backend-Status
sudo systemctl status myp-https.service
## Anpassung für andere Benutzer
# Kiosk-Status
sudo systemctl status myp-kiosk.service
Falls ein anderer Benutzer als `pi` verwendet wird, müssen folgende Anpassungen vorgenommen werden:
# Watchdog-Status
sudo systemctl status kiosk-watchdog.service
1. In `myp.service`: `User=` auf den entsprechenden Benutzer ändern
2. Pfade in `kiosk.sh` und `kiosk.service` anpassen
3. `loginctl enable-linger` für den entsprechenden Benutzer aktivieren
# Alle MYP-Services
sudo systemctl status myp-*
```
### Logs einsehen
```bash
# Backend-Logs
sudo journalctl -u myp-https.service -f
# Kiosk-Logs
sudo journalctl -u myp-kiosk.service -f
# System-Logs
tail -f /var/log/myp-kiosk.log
# Installation-Logs (falls verfügbar)
cat backend/logs/install-summary.txt
```
### Häufige Probleme
**Backend startet nicht:**
- Prüfen: `sudo systemctl status myp-https.service`
- Log: `sudo journalctl -u myp-https.service`
- Port-Konflikt: `sudo netstat -tulpn | grep :5000`
**Browser startet nicht:**
- X11-Display prüfen: `DISPLAY=:0 xset q`
- Kiosk-Benutzer prüfen: `id kiosk`
- Browser installiert: `which chromium-browser`
**Watchdog meldet Probleme:**
- Watchdog-Log: `sudo journalctl -u kiosk-watchdog.service`
- System-Ressourcen: `free -m && df -h`
## Konfiguration anpassen
### Backend-Port ändern
Bearbeiten Sie `/etc/systemd/system/myp-https.service`:
```ini
Environment=FLASK_PORT=8080
```
### Browser-Startseite ändern
Bearbeiten Sie `/etc/systemd/system/myp-kiosk.service` und ändern Sie:
```bash
TARGET_URL="http://localhost:5000"
```
### Watchdog-Intervall anpassen
Die Watchdog-Services können über ihre Konfigurationsdateien angepasst werden.
## Sicherheitshinweise
- Das System läuft mit root-Berechtigung für das Backend (für Druckerzugriff erforderlich)
- Der Browser läuft als separater `kiosk`-Benutzer
- Firewall ist automatisch konfiguriert
- Nur Port 5000 ist für lokale Verbindungen geöffnet
- HTTPS-Zertifikate werden automatisch generiert
## Performance-Optimierung
Für optimale Performance auf Raspberry Pi:
1. **GPU-Memory erhöhen:**
```bash
echo "gpu_mem=128" | sudo tee -a /boot/config.txt
```
2. **Swap verringern:**
```bash
echo "vm.swappiness=10" | sudo tee -a /etc/sysctl.conf
```
3. **I/O-Scheduler optimieren:**
```bash
echo "deadline" | sudo tee /sys/block/mmcblk0/queue/scheduler
```
## Updates
Updates der MYP-Anwendung:
```bash
cd /opt/myp
sudo git pull # falls Git-Repository
sudo systemctl restart myp-https.service
sudo systemctl restart myp-kiosk.service
```
## Deinstallation
Vollständige Entfernung:
```bash
sudo systemctl disable --now myp-https.service myp-kiosk.service
sudo systemctl disable --now kiosk-watchdog.service myp-firewall.service
sudo rm /etc/systemd/system/myp-*.service
sudo rm /etc/systemd/system/kiosk-*.service
sudo systemctl daemon-reload
sudo userdel -r kiosk
sudo rm -rf /opt/myp
```
## Support
Bei Problemen:
1. Prüfen Sie die Logs in `backend/logs/`
2. Verwenden Sie `sudo journalctl -u service-name` für Service-Logs
3. Stellen Sie sicher, dass alle Voraussetzungen erfüllt sind
4. Führen Sie das Setup-Script erneut aus bei Installations-Problemen