core/Projektarbeit-MYP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Projektarbeit-MYP/backend/docs/RASPBERRY_PI_OPTIMIERUNG.md

8.3 KiB
Raw Blame History

MYP Platform - Raspberry Pi Performance Optimierung

Übersicht

Diese Dokumentation beschreibt die implementierten Performance-Optimierungen für die MYP Flask-Webapp, um eine optimale Leistung auf Raspberry Pi Hardware zu gewährleisten.

Implementierte Optimierungen

1. Kernel- und System-Optimierungen (setup.sh)

Kernel-Parameter

# Memory Management
vm.swappiness=10                    # Reduzierte Swap-Nutzung
vm.dirty_ratio=5                    # Frühere Disk-Writes
vm.dirty_background_ratio=2         # Hintergrund-Writes
vm.vfs_cache_pressure=50           # Ausgewogenes Cache-Verhalten

# CPU Scheduler
kernel.sched_migration_cost_ns=5000000    # Reduzierte CPU-Migration
kernel.sched_autogroup_enabled=0          # Deaktivierte Auto-Gruppierung

# Filesystem (SD-Card optimiert)
vm.dirty_expire_centisecs=500       # Schnellere Daten-Expiration
vm.dirty_writeback_centisecs=100    # Häufigere Writebacks

Service-Deaktivierung

  • bluetooth.service - Bluetooth-Dienst
  • cups.service - Druckerdienst (nicht benötigt)
  • avahi-daemon.service - mDNS-Dienst
  • ModemManager.service - Modem-Manager
  • wpa_supplicant.service - WiFi falls Ethernet verwendet

tmpfs-Optimierung

# Temporäre Dateien im RAM
/tmp tmpfs defaults,noatime,nosuid,size=100M 0 0
/var/tmp tmpfs defaults,noatime,nosuid,size=50M 0 0
/var/log tmpfs defaults,noatime,nosuid,size=50M 0 0

2. Python/Flask-Optimierungen (app.py)

Speicher-Management

# Garbage Collection optimiert
gc.set_threshold(700, 10, 10)  # Häufigere Bereinigung
gc.collect()  # Initial cleanup

# Memory Limits
resource.setrlimit(resource.RLIMIT_AS, (256 * 1024 * 1024, 256 * 1024 * 1024))

Flask-Konfiguration

# Performance-Optimierungen
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 31536000  # 1 Jahr Cache
app.config['JSON_SORT_KEYS'] = False
app.config['JSONIFY_PRETTYPRINT_REGULAR'] = False
app.config['TEMPLATES_AUTO_RELOAD'] = False

API-Optimierungen

  • Pagination: Maximale 50 Items pro Request
  • Lazy Loading: Bedarfsgerechtes Laden von Daten
  • Cache Headers: Aggressive Caching-Strategien
  • Response Compression: Gzip-Kompression für alle Responses

3. Datenbank-Optimierungen (models.py)

SQLite-Konfiguration für Raspberry Pi

# Reduzierte Cache-Größen
'pool_pre_ping': True,
'pool_recycle': 300,
'connect_args': {
    'check_same_thread': False,
    'timeout': 30,  # Längere Timeouts für SD-Karten
    'cached_statements': 100,
    'isolation_level': None,
    'sqlite_additional_pragmas': {
        'cache_size': -32000,      # 32MB Cache (reduziert)
        'mmap_size': 134217728,    # 128MB Memory-mapped I/O
        'page_size': 4096,         # SD-Card optimiert
        'wal_autocheckpoint': 100, # Häufigere WAL-Checkpoints
        'max_wal_size': 33554432   # 32MB WAL-Limit
    }
}

Connection Pooling

  • Pool Size: 3 Verbindungen (reduziert)
  • Pool Recycle: 300 Sekunden
  • Timeouts: 30 Sekunden für SD-Karten-Latenz

4. Frontend-Optimierungen

Critical CSS (critical.min.css)

  • Inline-CSS: Kritische Styles für First Paint
  • Minimiert: Nur essentielle Styles (2.4KB)
  • Mobile-First: Responsive Design optimiert

JavaScript-Loader (loader.min.js)

  • Lazy Loading: JavaScript nach User-Interaktion
  • Cache-Strategie: Intelligent caching mit Service Worker
  • Minimiert: Kompakte 1.8KB Datei
  • SPA-Navigation: Client-side Routing für bessere Performance

Service Worker (sw-optimized.js)

  • Cache-Limit: Maximal 50 Einträge für Raspberry Pi
  • Intelligente Strategien:
    • API: Network First mit Cache Fallback
    • Statische Assets: Cache First
    • HTML-Seiten: Network First mit Cache Fallback
  • Hintergrund-Sync: Automatische Datensynchronisation
  • Offline-Support: Vollständige Offline-Funktionalität

Performance Features

// Debounce für Events
MYP.debounce(func, 250);

// Throttle für Scroll-Events
MYP.throttle(func, 100);

// Lazy Image Loading
MYP.lazyImages();

// Cache-Management
MYP.cache(url);
MYP.store(url, data);

5. Build-System-Optimierungen

Asset-Kompression

# Gzip-Kompression für statische Dateien
find static/ -name "*.css" -o -name "*.js" | xargs gzip -k -9

# CSS-Minimierung
npx tailwindcss build -i input.css -o critical.min.css --minify

# JavaScript-Minimierung
npx terser app.js -c -m -o loader.min.js

Package-Management

  • Spezifische Versionen: Locked versions in package.json
  • Minimal Dependencies: Nur benötigte Pakete
  • Production Build: Optimierte Builds für Deployment

Performance-Metriken

Erwartete Verbesserungen

  • Ladezeit: 40-60% Reduktion
  • Speicherverbrauch: 30-40% Reduktion
  • CPU-Last: 25-35% Reduktion
  • Netzwerk-Traffic: 50-70% Reduktion (durch Caching)

Monitoring

// Performance-Monitoring in base.html
window.addEventListener('load', function() {
    const loadTime = performance.timing.loadEventEnd - performance.timing.navigationStart;
    if (loadTime > 3000) {
        console.warn('Langsame Ladezeit:', loadTime + 'ms');
    }
});

Installation und Verwendung

Automatische Installation

# Vollständige Installation mit Performance-Optimierungen
sudo ./setup.sh

# Nur Performance-Optimierungen anwenden
sudo ./setup.sh --performance-only

Manuelle Konfiguration

1. Kernel-Parameter anwenden

sudo sysctl -p /etc/sysctl.d/99-myp-performance.conf

2. systemd-Dienste deaktivieren

sudo systemctl disable bluetooth cups avahi-daemon

3. tmpfs mounten

sudo mount -a

4. Python-Optimierungen aktivieren

export PYTHONOPTIMIZE=2
export PYTHONDONTWRITEBYTECODE=1

Troubleshooting

Häufige Probleme

1. Hoher Speicherverbrauch

# Memory-Monitoring
free -h
sudo systemctl status myp-webapp

# Log-Analyse
tail -f logs/app/app.log

2. Langsame Datenbankoperationen

# SQLite-Performance prüfen
sqlite3 instance/myp.db ".timer on" "PRAGMA cache_size;"

# Index-Optimierung
sqlite3 instance/myp.db "ANALYZE;"

3. Service Worker Probleme

// Browser-Konsole
navigator.serviceWorker.getRegistrations().then(function(registrations) {
    registrations.forEach(function(registration) {
        console.log('SW:', registration.scope, registration.active.state);
    });
});

Performance-Debugging

1. Network-Tab

  • Prüfe Cache-Headers
  • Identifiziere langsame Requests
  • Überwache Transfer-Größen

2. Performance-Tab

  • Messe JavaScript-Ausführungszeit
  • Identifiziere Layout-Thrashing
  • Überwache Memory-Leaks

3. Server-Logs

# Flask-Performance-Logs
tail -f logs/app/performance.log

# System-Performance
htop
iotop -a

Wartung

Tägliche Tasks

# Cache-Bereinigung (automatisch via Cron)
0 2 * * * /usr/local/bin/cleanup-cache.sh

# Log-Rotation
0 0 * * * /usr/sbin/logrotate /etc/logrotate.d/myp-webapp

Wöchentliche Tasks

# Datenbank-Optimierung
0 1 * * 0 sqlite3 /path/to/myp.db "VACUUM; ANALYZE;"

# System-Update mit Performance-Check
0 3 * * 0 /usr/local/bin/system-maintenance.sh

Monitoring

# Performance-Metriken sammeln
*/5 * * * * /usr/local/bin/collect-metrics.sh

# Alert bei schlechter Performance
*/10 * * * * /usr/local/bin/performance-alert.sh

Weitere Optimierungen

Hardware-spezifisch

  • SD-Karte: Class 10 oder besser verwenden
  • RAM: Mindestens 2GB empfohlen für bessere Performance
  • CPU: Übertaktung wenn Kühlung ausreichend

Netzwerk

  • Ethernet: Bevorzugt gegenüber WiFi
  • QoS: Traffic-Priorisierung für kritische Services
  • DNS: Lokaler DNS-Cache (unbound)

Erweiterte Optimierungen

  • Redis: Externes Caching für Skalierung
  • nginx: Reverse Proxy für statische Assets
  • Load Balancer: Mehrere Raspberry Pi für High Availability

Backup und Recovery

Automatisches Backup

# Tägliches Backup mit Kompression
0 1 * * * /usr/local/bin/backup-myp.sh --compress --performance-optimized

Recovery-Prozess

# Schnelle Wiederherstellung
sudo ./setup.sh --restore-from-backup --performance-mode

# Performance-Check nach Restore
sudo ./setup.sh --performance-check

Erstellt: $(date '+%Y-%m-%d %H:%M:%S')
Version: 1.0
Status: Produktionsbereit