Kapitel 7/Premium Rohtext.md hinzugefügt

2025-10-05 19:00:58 +00:00
parent 572945256b
commit a4cf79fbc6
1 changed files with 928 additions and 0 deletions
--- a/Rohtext.md
+++ b/Rohtext.md
@@ -0,0 +1,928 @@
+# Kapitel 7 – Affine (Premium)
+
+## Einleitung
+
+Affine ist dein digitales Planungssystem – der Ort, an dem Ideen, Notizen und Projekte zusammenlaufen.  
+Im Premium-Kapitel erweitern wir diese Arbeitsumgebung um alle Funktionen,  
+die sie zu einem professionellen, selbstverwalteten System machen:  
+von automatischen Backups über Vorlagen-Bibliotheken bis hin zu Performance-Optimierungen und Statusprüfungen.
+
+Ziel ist ein Affine-Server, der sich selbst pflegt, regelmäßig sichert und gleichzeitig mehr Komfort bei der täglichen Nutzung bietet.  
+So arbeitest du produktiv, ohne dich um Wartung, Updates oder Datenverlust sorgen zu müssen.
+
+> [!NOTE]  
+> Premium bedeutet im UCC-Tutorial nicht mehr Komplexität, sondern mehr Automatisierung und Zuverlässigkeit.  
+> Jede Erweiterung lässt sich Schritt für Schritt aktivieren, unabhängig davon,  
+> ob du Affine allein oder im Team nutzt.
+
+### Themen dieses Kapitels
+
+1. **Vorlagen-Paket für Affine**  
+   – fertige Workspaces, Boards und Dokumentstrukturen zur direkten Nutzung  
+
+2. **Automatische Sicherung der PostgreSQL-Datenbank**  
+   – tägliche Backups inklusive Protokollierung und Aufbewahrungszeit  
+
+3. **Mail-Benachrichtigung über Backup-Status**  
+   – automatische E-Mail bei Erfolg oder Fehler  
+
+4. **Workspace-Export & Archivierung**  
+   – automatische JSON- oder ZIP-Exporte deiner Workspaces für das UCC-Archiv  
+
+5. **Automatischer Container-Healthcheck & Neustart**  
+   – regelmäßige Prüfung und Selbstheilung des Affine-Stacks  
+
+6. **Manuelles Update-Skript für Docker Compose**  
+   – einfache Befehlsausführung zur Aktualisierung aller Container  
+
+7. **Performance-Tuning für PostgreSQL & Redis**  
+   – optimierte Konfigurationswerte für schnellere Reaktionszeiten  
+
+8. **Abschluss & Nächste Schritte**  
+   – Übersicht aller Erweiterungen und Wartungsroutinen  
+
+> [!TIP]  
+> Wenn du alle Schritte in diesem Kapitel umsetzt, erhältst du eine Affine-Instanz,  
+> die sich automatisch aktualisiert, sichert und überwacht –  
+> ganz ohne externe Tools oder manuelle Eingriffe.
+
+👉 *Screenshot geeignet: Affine-Dashboard mit geöffnetem Workspace und angezeigtem Backup-Status.*
+
+---
+
+## Vorlagen-Paket (Bratonien Creator Panel)
+
+Das Vorlagen-Paket ist der praktische Kern dieses Premium-Kapitels.  
+Es enthält einen vollständig vorbereiteten Workspace mit dem Namen **„Bratonien Creator Panel“**,  
+der alle Strukturen, Tabellen, Ansichten und Beispielinhalte enthält, die Content Creator für ihre tägliche Arbeit benötigen.  
+Dieser Workspace bildet die Grundlage für eigene Projekte, Ideen, Streams und Aufgaben innerhalb deines UCC-Systems.
+
+> [!NOTE]  
+> Der Workspace ist sofort einsatzbereit.  
+> Du kannst ihn importieren, anpassen und nach Belieben erweitern.  
+> Alle Anpassungen bleiben beim nächsten Update erhalten, da die Datei nur als Vorlage dient.
+
+### Ziel des Vorlagen-Pakets
+
+- Einheitliche Arbeitsumgebung für alle Creator-Prozesse  
+- Planung, Produktion und Veröffentlichung in einer Oberfläche  
+- Sponsoren- und Aufgabenverwaltung integriert  
+- Kombinierte Kalender-, Board- und Listenansichten  
+- Kompatibel mit späteren n8n-Automatisierungen und Backup-Routinen
+
+### Import des Workspaces
+
+1. Lade die bereitgestellte JSON-Datei von der Premium-Downloadseite:  
+   `https://ucc.brationien.de/downloads/affine/bratonien-creator-panel.json`  
+2. Öffne Affine → **Workspaces → Import Workspace**  
+3. Wähle die heruntergeladene Datei aus.  
+   Der neue Bereich erscheint danach automatisch in der linken Seitenleiste.  
+4. Öffne den Workspace und aktiviere den **Dark-Mode** über das Zahnrad-Symbol oben rechts.
+
+> [!NOTE]  
+> Beim Import erzeugt Affine automatisch neue interne IDs.  
+> Der Inhalt bleibt unverändert, sodass du sofort loslegen kannst.
+
+### Inhalt des Vorlagen-Pakets
+
+Der Workspace enthält mehrere vollständig vorbereitete Bereiche:
+
+| Bereich | Beschreibung |
+|----------|--------------|
+| **Projekte** | Übersicht aller geplanten oder laufenden Inhalte wie Videos, Streams oder Posts |
+| **Aufgaben** | Eigenständige oder projektbezogene To-Dos mit Status und Priorität |
+| **Sponsoren** | Verwaltung aktiver Kooperationen und Partner |
+| **Ideen & Themen** | Sammelstelle für neue Konzepte und Formate |
+| **Content-Kalender** | Terminplanung für Veröffentlichungen und Streams |
+| **Dashboard** | Zusammenfassung aller Module mit Filter- und Fortschrittsanzeigen |
+
+> [!TIP]  
+> Alle Bereiche sind miteinander verknüpft.  
+> Eine Änderung, etwa am Status eines Projekts, wird in allen Ansichten automatisch übernommen.
+
+### Platzhalter für die JSON-Datei
+
+Im finalen Tutorial-Release wird hier der vollständige JSON-Block des „Bratonien Creator Panel“ eingefügt.  
+Bis dahin findest du die aktuelle Version stets auf der Premium-Downloadseite.
+
+```
+[AFFINE_JSON_WORKSPACE]
+```
+
+> [!IMPORTANT]  
+> Der Platzhalter wird im veröffentlichten Premium-Material automatisch ersetzt,  
+> sobald der geprüfte JSON-Export aus Affine vorliegt.  
+> Damit bleibt dieses Kapitel immer aktuell, auch wenn später neue Felder oder Ansichten ergänzt werden.
+
+## Automatische Sicherung der PostgreSQL-Datenbank
+
+Damit alle Daten deines Affine-Workspaces – Projekte, Aufgaben, Ideen und Beziehungen – dauerhaft gesichert bleiben,  
+richten wir eine tägliche automatische Sicherung der PostgreSQL-Datenbank ein.  
+Das Skript erstellt nicht nur ein neues Backup, sondern löscht gleichzeitig alle älteren Sicherungen,  
+die länger als 30 Tage gespeichert sind.  
+So bleibt dein Speicherplatz sauber, ohne dass du manuell eingreifen musst.
+
+> [!NOTE]  
+> Gesichert wird ausschließlich die Affine-Datenbank.  
+> Template-Dateien oder JSON-Exporte werden separat im Abschnitt „Workspace-Export & Archivierung“ behandelt.
+
+### Ziel
+
+- Tägliche automatische Sicherung der Affine-Datenbank  
+- Automatische Löschung von Backups älter als 30 Tage  
+- Zeitstempel im Dateinamen für klare Nachverfolgbarkeit  
+- Protokollierung aller Abläufe in einer Logdatei  
+- Sichere Wiederherstellung im Bedarfsfall  
+
+### Sicherungsskript anlegen
+
+Öffne im Terminal des Affine-Containers den Editor und erstelle das Skript:
+
+```bash
+nano /usr/local/bin/affine_backup.sh
+```
+
+Füge folgenden Inhalt ein:
+
+```bash
+#!/bin/bash
+#
+# affine_backup.sh
+# Erstellt ein tägliches Backup der Affine-Datenbank
+# und löscht automatisch alle Backups, die älter als 30 Tage sind.
+#
+
+BACKUP_DIR="/mnt/hdd/affine_backups"
+DATE=$(date +'%Y-%m-%d_%H-%M')
+DB_NAME="affine"
+DB_USER="affine"
+DB_PASS="DEIN_SICHERES_PASSWORT"
+LOGFILE="/var/log/affine_backup.log"
+
+mkdir -p "$BACKUP_DIR"
+
+echo "[$(date +'%d.%m.%Y %H:%M:%S')] Backup gestartet" >> "$LOGFILE"
+
+# Datenbank sichern
+pg_dump -U "$DB_USER" "$DB_NAME" > "$BACKUP_DIR/db_${DATE}.sql"
+
+if [ $? -eq 0 ]; then
+  echo "[$(date +'%d.%m.%Y %H:%M:%S')] Backup erfolgreich erstellt: db_${DATE}.sql" >> "$LOGFILE"
+else
+  echo "[$(date +'%d.%m.%Y %H:%M:%S')] FEHLER: Backup fehlgeschlagen" >> "$LOGFILE"
+fi
+
+# Alte Backups löschen (älter als 30 Tage)
+find "$BACKUP_DIR" -type f -name "db_*.sql" -mtime +30 -print -delete >> "$LOGFILE" 2>&1
+
+echo "[$(date +'%d.%m.%Y %H:%M:%S')] Alte Backups (älter als 30 Tage) gelöscht" >> "$LOGFILE"
+echo "[$(date +'%d.%m.%Y %H:%M:%S')] Backup abgeschlossen" >> "$LOGFILE"
+```
+
+Datei speichern (**STRG + O**, Enter) und schließen (**STRG + X**).  
+Dann ausführbar machen:
+
+```bash
+chmod +x /usr/local/bin/affine_backup.sh
+```
+
+> [!NOTE]  
+> Das Skript legt alle Sicherungen unter `/mnt/hdd/affine_backups` ab und behält immer nur die letzten 30 Tage.  
+> Dadurch bleibt der Speicherverbrauch stabil und das Backup-Verzeichnis übersichtlich.
+
+### Automatische Ausführung einrichten
+
+Öffne die Cron-Konfiguration:
+
+```bash
+crontab -e
+```
+
+Am Ende hinzufügen:
+
+```bash
+0 4 * * * /usr/local/bin/affine_backup.sh
+```
+
+> [!TIP]  
+> Der Eintrag startet das Backup täglich um **04:00 Uhr**.  
+> Du kannst die Uhrzeit jederzeit anpassen, z. B. `0 2 * * *` für 02:00 Uhr.
+
+### Ergebnis prüfen
+
+Nach der ersten Ausführung kannst du die Sicherung überprüfen:
+
+```bash
+ls -lh /mnt/hdd/affine_backups
+```
+
+Du solltest eine Datei mit aktuellem Zeitstempel sehen, z. B.:
+
+```
+db_2025-10-05_04-00.sql
+```
+
+Das Protokoll zeigst du mit:
+
+```bash
+tail -n 20 /var/log/affine_backup.log
+```
+
+> [!TIP]  
+> Um das Backup sofort zu testen, führe das Skript manuell aus:
+> ```bash
+> /usr/local/bin/affine_backup.sh
+> ```
+> So erkennst du sofort, ob Pfade, Berechtigungen und Cron-Einträge korrekt sind.
+
+👉 *Screenshot geeignet: Terminal mit erfolgreichem Backup-Lauf und Logeinträgen über gelöschte alte Sicherungen.*
+
+### Wiederherstellung eines Backups
+
+Eine Sicherung ist nur dann wertvoll, wenn sie sich im Notfall auch sicher zurückspielen lässt.  
+Mit den folgenden Schritten stellst du deine Affine-Datenbank vollständig wieder her –  
+egal ob nach einem Defekt, einem fehlerhaften Update oder einem Systemumzug.
+
+#### Vorbereitung
+
+1. **Dienste stoppen**, damit keine Schreibvorgänge stattfinden:  
+   ```bash
+   systemctl stop affine
+   systemctl stop postgresql
+   ```
+
+2. **Backup-Verzeichnis prüfen:**  
+   ```bash
+   ls -lh /mnt/hdd/affine_backups
+   ```
+   Wähle die gewünschte Datei, z. B. `db_2025-10-05_04-00.sql`.
+
+#### Datenbank wiederherstellen
+
+1. PostgreSQL starten:  
+   ```bash
+   systemctl start postgresql
+   ```
+
+2. Alte Datenbank löschen und neu anlegen:  
+   ```bash
+   su - postgres
+   psql -c "DROP DATABASE affine;"
+   psql -c "CREATE DATABASE affine;"
+   psql -c "GRANT ALL PRIVILEGES ON DATABASE affine TO affine;"
+   exit
+   ```
+
+3. Sicherung einspielen:  
+   ```bash
+   psql -U affine -d affine < /mnt/hdd/affine_backups/db_2025-10-05_04-00.sql
+   ```
+
+> [!NOTE]  
+> Ersetze den Dateinamen durch das gewünschte Sicherungsdatum.  
+> Nach Abschluss siehst du im Terminal keine Fehlermeldung, wenn alles korrekt war.
+
+#### Neustart der Dienste
+
+Nach erfolgreicher Wiederherstellung startest du die Dienste neu:
+
+```bash
+systemctl start affine
+```
+
+> [!TIP]  
+> Falls du Redis oder zusätzliche Container (z. B. Nginx-Proxy) nutzt, starte sie ebenfalls neu,  
+> damit alle Abhängigkeiten sofort wieder aktiv sind.
+
+#### Funktionsprüfung
+
+Rufe deine Affine-Instanz im Browser auf:  
+```
+https://affine.DEINE-DOMAIN.tld
+```
+Melde dich an und prüfe, ob deine Workspaces, Projekte und Aufgaben wieder sichtbar sind.
+
+> [!NOTE]  
+> Wenn der Start ungewöhnlich lange dauert, initialisiert PostgreSQL interne Indexe neu.  
+> Nach wenigen Minuten ist das System wieder vollständig einsatzbereit.
+
+👉 *Screenshot geeignet: Terminal mit erfolgreicher Wiederherstellung und geöffneter Affine-Oberfläche.*
+
+## Mail-Benachrichtigung über Backup-Status
+
+Damit du nicht täglich manuell prüfen musst, ob deine automatischen Backups erfolgreich waren,  
+richten wir eine Benachrichtigung per E-Mail ein.  
+So erhältst du nach jedem Backup-Lauf eine kurze Nachricht, sobald ein Fehler oder Erfolg im Log vermerkt wurde.  
+
+> [!NOTE]  
+> Die Benachrichtigung nutzt das System-Mail-Programm des Containers.  
+> Es wird keine zusätzliche Software außerhalb von Affine benötigt.
+
+### Ziel
+
+- E-Mail-Benachrichtigung bei erfolgreichem oder fehlgeschlagenem Backup  
+- Kein manuelles Prüfen der Logdatei mehr nötig  
+- Verwendung des integrierten Mail-Systems (Postfix oder SSMTP)
+
+### Mail-System installieren
+
+Öffne im Terminal des Affine-Containers:  
+
+```bash
+apt install -y mailutils
+```
+
+> [!TIP]  
+> Dieses Paket stellt den Befehl `mail` bereit, mit dem Systemmeldungen versendet werden können.  
+> Bei Debian oder Ubuntu wird automatisch eine Basiskonfiguration erstellt, die sofort nutzbar ist.
+
+### Skript anpassen
+
+Öffne das zuvor angelegte Backup-Skript:  
+
+```bash
+nano /usr/local/bin/affine_backup.sh
+```
+
+Ersetze den unteren Teil durch folgende erweiterte Version:  
+
+```bash
+# Alte Backups löschen (älter als 30 Tage)
+find "$BACKUP_DIR" -type f -name "db_*.sql" -mtime +30 -print -delete >> "$LOGFILE" 2>&1
+echo "[$(date +'%d.%m.%Y %H:%M:%S')] Alte Backups (älter als 30 Tage) gelöscht" >> "$LOGFILE"
+
+# Mail-Benachrichtigung
+MAIL_TO="admin@DEINE-DOMAIN.tld"
+MAIL_SUBJECT="Affine Backup am $(date +'%d.%m.%Y %H:%M')"
+if grep -q "FEHLER" "$LOGFILE"; then
+  MAIL_SUBJECT="[FEHLER] $MAIL_SUBJECT"
+  mail -s "$MAIL_SUBJECT" "$MAIL_TO" < "$LOGFILE"
+else
+  mail -s "$MAIL_SUBJECT" "$MAIL_TO" < <(tail -n 20 "$LOGFILE")
+fi
+
+echo "[$(date +'%d.%m.%Y %H:%M:%S')] Mail-Benachrichtigung versendet" >> "$LOGFILE"
+echo "[$(date +'%d.%m.%Y %H:%M:%S')] Backup abgeschlossen" >> "$LOGFILE"
+```
+
+> [!NOTE]  
+> Ersetze `admin@DEINE-DOMAIN.tld` durch deine eigene E-Mail-Adresse.  
+> Falls du einen externen SMTP-Relay verwendest, kannst du die Serverdaten in `/etc/mail.rc` eintragen.  
+> Für lokale Benachrichtigungen reicht die Standardkonfiguration.
+
+Speichern (**STRG + O**, Enter) und schließen (**STRG + X**).  
+
+### Funktion testen
+
+Starte das Skript manuell:  
+
+```bash
+/usr/local/bin/affine_backup.sh
+```
+
+Wenn alles korrekt eingerichtet ist, erhältst du innerhalb weniger Sekunden eine E-Mail mit den letzten Logeinträgen.  
+
+> [!TIP]  
+> Wenn keine Nachricht ankommt, prüfe mit  
+> ```bash
+> tail -n 50 /var/log/mail.log
+> ```  
+> ob der Versand vom Mail-Dienst erfolgreich war oder eine Anmeldung am SMTP-Server fehlschlug.
+
+👉 *Screenshot geeignet: E-Mail-Posteingang mit erfolgreicher Backup-Benachrichtigung.*
+
+## Workspace-Export & Archivierung
+
+Neben der täglichen Datenbanksicherung empfiehlt es sich, regelmäßig komplette Workspaces als JSON-Dateien zu exportieren.  
+So kannst du deine Projekte, Aufgaben und Boards jederzeit wiederherstellen, auch wenn du versehentlich Daten gelöscht hast oder Affine auf einem neuen System einrichtest.
+
+> [!NOTE]  
+> Der Export enthält alle Seiten, Tabellen und Inhalte deines Workspaces – aber keine Benutzerkonten oder Logins.  
+> Er eignet sich ideal als persönliche Sicherung oder zum Austausch mit anderen Systemen.
+
+### Ziel
+
+- Regelmäßiger Export aller Workspaces als JSON  
+- Automatische Ablage mit Datum im Dateinamen  
+- Automatische Komprimierung der Exporte  
+- Einfache Wiederherstellung direkt über die Affine-Oberfläche  
+
+### Export-Skript anlegen
+
+Öffne im Terminal deines Affine-Containers den Editor:
+
+```bash
+nano /usr/local/bin/affine_export.sh
+```
+
+Füge folgenden Inhalt ein:
+
+```bash
+#!/bin/bash
+#
+# affine_export.sh
+# Exportiert alle Affine-Workspaces als JSON und erstellt ein tägliches Archiv
+#
+
+EXPORT_DIR="/mnt/hdd/affine_exports"
+DATE=$(date +'%Y-%m-%d_%H-%M')
+LOGFILE="/var/log/affine_export.log"
+
+mkdir -p "$EXPORT_DIR"
+
+echo "[$(date +'%d.%m.%Y %H:%M:%S')] Export gestartet" >> "$LOGFILE"
+
+# Beispielhafter Export – je nach Version kann der API-Pfad abweichen
+curl -s http://localhost:3010/api/workspaces/export -o "$EXPORT_DIR/workspace_${DATE}.json"
+
+# Archiv erstellen
+tar -czf "$EXPORT_DIR/workspace_${DATE}.tar.gz" -C "$EXPORT_DIR" "workspace_${DATE}.json"
+rm "$EXPORT_DIR/workspace_${DATE}.json"
+
+# Alte Exporte löschen (älter als 30 Tage)
+find "$EXPORT_DIR" -type f -name "workspace_*.tar.gz" -mtime +30 -print -delete >> "$LOGFILE" 2>&1
+
+echo "[$(date +'%d.%m.%Y %H:%M:%S')] Export abgeschlossen" >> "$LOGFILE"
+```
+
+Datei speichern (**STRG + O**, Enter) und schließen (**STRG + X**).  
+Dann ausführbar machen:
+
+```bash
+chmod +x /usr/local/bin/affine_export.sh
+```
+
+> [!NOTE]  
+> Die Beispiel-URL `http://localhost:3010/api/workspaces/export` kann je nach Version variieren.  
+> Prüfe sie in deiner Affine-Oberfläche unter **Settings → API → Export**.
+
+### Automatische Ausführung einrichten
+
+Öffne den Cron-Editor:
+
+```bash
+crontab -e
+```
+
+Füge den folgenden Eintrag hinzu:
+
+```bash
+15 4 * * * /usr/local/bin/affine_export.sh
+```
+
+> [!TIP]  
+> Dadurch erfolgt der Export täglich um **04:15 Uhr**, direkt nach der Datenbanksicherung.  
+> Beide Sicherungen laufen so automatisch hintereinander.
+
+### Ergebnis prüfen
+
+Nach dem ersten Lauf kannst du die Exporte prüfen:
+
+```bash
+ls -lh /mnt/hdd/affine_exports
+```
+
+Die Ausgabe sollte eine neue Archivdatei zeigen, z. B.:
+
+```
+workspace_2025-10-05_04-15.tar.gz
+```
+
+Das Protokoll siehst du mit:
+
+```bash
+tail -n 20 /var/log/affine_export.log
+```
+
+> [!TIP]  
+> Führe das Skript bei Bedarf manuell aus, um die Funktion sofort zu testen:
+> ```bash
+> /usr/local/bin/affine_export.sh
+> ```
+
+👉 *Screenshot geeignet: Terminal mit erfolgreichem JSON-Export und Archivdatei.*
+
+### Sicherung verwenden
+
+Alle erstellten Archive findest du im Ordner:
+
+```
+/mnt/hdd/affine_exports
+```
+
+Von dort kannst du sie bei Bedarf einfach auf deinen Computer herunterladen,  
+um sie lokal aufzubewahren oder in einer anderen Affine-Installation wieder zu importieren.
+
+> [!TIP]  
+> Der einfachste Weg ist der Download über **SFTP** oder die Dateifreigabe deiner Wahl.  
+> Du musst keine zusätzlichen Programme oder Server einrichten – die Archive sind normale Dateien.
+
+### Wiederherstellung eines Workspace-Exports
+
+Um einen gespeicherten Workspace wiederherzustellen:
+
+1. Entpacke das gewünschte Archiv auf deinem Computer.  
+2. Öffne in Affine das Menü **Workspaces → Import Workspace**.  
+3. Wähle die entpackte JSON-Datei aus.  
+4. Bestätige mit **Importieren**.
+
+> [!NOTE]  
+> Affine legt beim Import neue interne IDs an,  
+> sodass du alte und neue Versionen eines Workspaces parallel nutzen kannst.  
+> So lassen sich frühere Stände vergleichen, ohne aktuelle Daten zu überschreiben.
+
+👉 *Screenshot geeignet: Affine-Importdialog mit ausgewählter JSON-Datei.*
+
+## Automatischer Container-Healthcheck & Neustart
+
+Damit dein Affine-System dauerhaft stabil bleibt, richten wir einen automatischen Gesundheitscheck (Healthcheck) für den Container ein.  
+Dieser prüft regelmäßig, ob alle Dienste laufen und die Weboberfläche erreichbar ist.  
+Falls ein Problem erkannt wird – etwa ein abgestürzter Prozess oder ein blockierter Dienst – startet der Container selbstständig neu.  
+
+> [!NOTE]  
+> Dieser Mechanismus ersetzt keine Backups, sondern stellt sicher, dass Affine auch nach längerer Laufzeit ohne manuelles Eingreifen zuverlässig verfügbar bleibt.
+
+### Ziel
+
+- Regelmäßige automatische Prüfung des Affine-Containers  
+- Automatischer Neustart bei Nichterreichbarkeit  
+- Protokollierung der Ergebnisse in einer Logdatei  
+- Keine Unterbrechungen bei längeren Betriebszeiten  
+
+### Healthcheck-Skript anlegen
+
+Öffne im Terminal deines Proxmox-Hosts (nicht im Container!) den Editor:  
+
+```bash
+nano /usr/local/bin/affine_healthcheck.sh
+```
+
+Füge folgenden Inhalt ein:  
+
+```bash
+#!/bin/bash
+#
+# affine_healthcheck.sh
+# Prüft den Status des Affine-Containers und startet ihn bei Bedarf neu
+#
+
+CTID=107            # Container-ID aus Proxmox
+LOGFILE="/var/log/affine_healthcheck.log"
+AFFINE_URL="http://192.168.1.70:3010"  # interne Adresse des Affine-Containers
+
+echo "[$(date +'%d.%m.%Y %H:%M:%S')] Healthcheck gestartet" >> "$LOGFILE"
+
+# HTTP-Test – prüft, ob die Weboberfläche erreichbar ist
+if curl -s --head "$AFFINE_URL" | grep -q "200 OK"; then
+  echo "[$(date +'%d.%m.%Y %H:%M:%S')] Affine läuft normal" >> "$LOGFILE"
+else
+  echo "[$(date +'%d.%m.%Y %H:%M:%S')] FEHLER: Affine nicht erreichbar – Neustart wird ausgeführt" >> "$LOGFILE"
+  pct restart $CTID
+  echo "[$(date +'%d.%m.%Y %H:%M:%S')] Container $CTID neu gestartet" >> "$LOGFILE"
+fi
+```
+
+Datei speichern (**STRG + O**, Enter) und schließen (**STRG + X**).  
+Danach ausführbar machen:  
+
+```bash
+chmod +x /usr/local/bin/affine_healthcheck.sh
+```
+
+> [!NOTE]  
+> Ersetze `CTID=107` durch die tatsächliche Container-ID deiner Affine-Installation.  
+> Die IP-Adresse (`192.168.1.70`) ist die interne Adresse des Containers aus Kapitel 7.
+
+### Automatische Ausführung einrichten
+
+Öffne den Cron-Editor auf dem Proxmox-Host:  
+
+```bash
+crontab -e
+```
+
+Füge am Ende der Datei hinzu:  
+
+```bash
+*/30 * * * * /usr/local/bin/affine_healthcheck.sh
+```
+
+> [!TIP]  
+> Dieser Eintrag prüft den Container alle **30 Minuten**.  
+> Du kannst den Intervall verkürzen, z. B. alle 10 Minuten mit `*/10 * * * *`.
+
+### Funktion prüfen
+
+Führe den Healthcheck manuell aus, um die Funktion zu testen:  
+
+```bash
+/usr/local/bin/affine_healthcheck.sh
+```
+
+Wenn Affine erreichbar ist, erscheint im Log:
+
+```
+[05.10.2025 18:00:00] Affine läuft normal
+```
+
+Wenn die Oberfläche absichtlich gestoppt wurde (z. B. durch `pct stop 107`),  
+führt das Skript beim nächsten Lauf automatisch einen Neustart durch.
+
+> [!NOTE]  
+> Der Neustart ist sehr schnell – in der Regel weniger als 10 Sekunden.  
+> Das verhindert Ausfälle und sorgt dafür, dass dein Dashboard, Boards und Projekte jederzeit verfügbar sind.
+
+### Logdatei prüfen
+
+Die Ergebnisse findest du unter:
+
+```
+/var/log/affine_healthcheck.log
+```
+
+Mit diesem Befehl siehst du die letzten Einträge:
+
+```bash
+tail -n 20 /var/log/affine_healthcheck.log
+```
+
+> [!TIP]  
+> Du kannst das Log jederzeit löschen oder archivieren,  
+> indem du es mit `truncate -s 0 /var/log/affine_healthcheck.log` leerst.
+
+👉 *Screenshot geeignet: Terminal mit erfolgreichem Healthcheck und Neustartmeldung.*
+
+## Manuelles Update-Skript für Docker Compose
+
+Affine wird in der Regel über Docker Compose betrieben.  
+Damit du die Kontrolle über alle Aktualisierungen behältst,  
+erstellen wir ein einfaches Skript, das den gesamten Stack in wenigen Sekunden aktualisiert.  
+Das erspart dir komplizierte Befehle und sorgt dafür, dass du jederzeit die neueste Version nutzen kannst.
+
+> [!NOTE]  
+> Dieses Verfahren ersetzt automatische Updates bewusst.  
+> Du entscheidest selbst, wann ein Update durchgeführt wird,  
+> um deine laufenden Projekte nicht zu unterbrechen.
+
+### Ziel
+
+- Manuelles, aber vereinfachtes Update aller Container  
+- Sicherer Ablauf mit Backup und Log  
+- Vollständige Kontrolle über Zeitpunkt und Ausführung  
+
+### Update-Skript anlegen
+
+Öffne im Terminal deines Affine-Containers den Editor:
+
+```bash
+nano /usr/local/bin/affine_update.sh
+```
+
+Füge folgenden Inhalt ein:
+
+```bash
+#!/bin/bash
+#
+# affine_update.sh
+# Führt ein manuelles Update des Affine-Stacks über Docker Compose aus
+#
+
+STACK_DIR="/srv/affine"
+LOGFILE="/var/log/affine_update.log"
+DATE=$(date +'%Y-%m-%d_%H-%M')
+
+echo "[$(date +'%d.%m.%Y %H:%M:%S')] Update gestartet" >> "$LOGFILE"
+
+cd "$STACK_DIR" || exit 1
+
+# Kurzes Backup der aktuellen Compose-Datei
+cp docker-compose.yml docker-compose-backup_${DATE}.yml
+
+# Container aktualisieren
+docker compose pull >> "$LOGFILE" 2>&1
+docker compose up -d --remove-orphans >> "$LOGFILE" 2>&1
+
+# Alte Compose-Backups löschen (älter als 30 Tage)
+find "$STACK_DIR" -type f -name "docker-compose-backup_*.yml" -mtime +30 -delete
+
+echo "[$(date +'%d.%m.%Y %H:%M:%S')] Update abgeschlossen" >> "$LOGFILE"
+```
+
+Datei speichern (**STRG + O**, Enter) und schließen (**STRG + X**).  
+Dann ausführbar machen:
+
+```bash
+chmod +x /usr/local/bin/affine_update.sh
+```
+
+> [!NOTE]  
+> Das Skript kann jederzeit ausgeführt werden, ohne laufende Workspaces zu beschädigen.  
+> Docker lädt nur neue Images herunter und startet die Container neu.
+
+### Update ausführen
+
+Rufe das Skript manuell auf:
+
+```bash
+/usr/local/bin/affine_update.sh
+```
+
+Während des Vorgangs werden alle Container neu gestartet und im Log protokolliert:
+
+```bash
+tail -n 20 /var/log/affine_update.log
+```
+
+> [!TIP]  
+> Führe ein Update nur dann durch, wenn keine größeren Arbeiten offen sind.  
+> So verhinderst du, dass ein Neustart laufende Änderungen unterbricht.
+
+### Fehlerbehebung
+
+Wenn beim Update eine Fehlermeldung auftritt, kannst du den letzten funktionierenden Stand wiederherstellen:
+
+```bash
+cp /srv/affine/docker-compose-backup_YYYY-MM-DD_HH-MM.yml /srv/affine/docker-compose.yml
+docker compose up -d
+```
+
+> [!NOTE]  
+> Dadurch nutzt du wieder die vorherige Version des Compose-Stacks.  
+> Alle Workspaces und Daten bleiben dabei erhalten.
+
+👉 *Screenshot geeignet: Terminal mit erfolgreichem Update-Lauf und Logausgabe.*
+
+## Performance-Tuning für PostgreSQL & Redis
+
+Damit Affine auch bei großen Workspaces und vielen Inhalten flüssig läuft,  
+optimieren wir zum Abschluss die Konfiguration von PostgreSQL und Redis.  
+Beide Systeme sind die Grundlage für schnelle Datenzugriffe, sauberes Caching und kurze Ladezeiten.
+
+> [!NOTE]  
+> Diese Werte sind für Container mit **4–8 GB RAM** optimiert.  
+> Du kannst sie später anpassen, wenn dein System über mehr Speicher verfügt.
+
+### Ziel
+
+- Schnellere Datenbankabfragen  
+- Geringere Verzögerungen bei großen Workspaces  
+- Bessere Nutzung des Arbeitsspeichers  
+- Weniger Schreibzugriffe auf die Festplatte  
+
+### PostgreSQL optimieren
+
+Öffne die Konfigurationsdatei im Container:
+
+```bash
+nano /etc/postgresql/16/main/postgresql.conf
+```
+
+Suche die folgenden Zeilen und ändere oder ergänze sie wie angegeben:
+
+```ini
+# Arbeitsspeicher
+shared_buffers = 512MB
+work_mem = 16MB
+maintenance_work_mem = 128MB
+
+# Caching & I/O
+effective_cache_size = 2GB
+random_page_cost = 1.1
+seq_page_cost = 1.0
+synchronous_commit = off
+
+# Logging
+log_min_duration_statement = 500
+```
+
+> [!TIP]  
+> Diese Werte reduzieren die Zugriffszeiten bei großen Tabellen und beschleunigen Schreibvorgänge.  
+> `synchronous_commit = off` spart Schreibzyklen und ist in Containern sicher, da das Dateisystem synchronisiert bleibt.
+
+Speichern mit **STRG + O**, Enter, und schließen mit **STRG + X**.  
+Danach PostgreSQL neu starten:
+
+```bash
+systemctl restart postgresql
+```
+
+Zur Kontrolle:
+
+```bash
+systemctl status postgresql
+```
+
+👉 *Screenshot geeignet: Terminal mit erfolgreichem Neustart und Status „active (running)“.*
+
+### Redis optimieren
+
+Redis sorgt dafür, dass häufig verwendete Daten im Arbeitsspeicher zwischengespeichert werden.  
+Durch ein paar Anpassungen lässt sich die Performance weiter steigern.
+
+Öffne die Konfigurationsdatei:
+
+```bash
+nano /etc/redis/redis.conf
+```
+
+Suche und passe folgende Werte an:
+
+```ini
+# Arbeitsspeicherlimit
+maxmemory 256mb
+maxmemory-policy allkeys-lru
+
+# Speichernutzung
+lazyfree-lazy-eviction yes
+lazyfree-lazy-expire yes
+lazyfree-lazy-server-del yes
+
+# Hintergrund-Speicherung
+save 900 1
+save 300 10
+save 60 10000
+```
+
+> [!NOTE]  
+> Diese Einstellungen sorgen dafür, dass ungenutzte Schlüssel automatisch entfernt werden  
+> und Redis Speicher effizient freigibt, ohne den Hauptprozess zu blockieren.
+
+Speichern (**STRG + O**, Enter, **STRG + X**)  
+und Redis neu starten:
+
+```bash
+systemctl restart redis-server
+```
+
+Überprüfen, ob Redis korrekt läuft:
+
+```bash
+redis-cli ping
+```
+
+Wenn `PONG` erscheint, funktioniert der Cache einwandfrei.
+
+### Wirkung prüfen
+
+1. Öffne deinen Affine-Workspace im Browser.  
+2. Lade eine größere Seite oder Tabelle.  
+3. Wiederhole den Vorgang nach dem Neustart –  
+   du wirst feststellen, dass die Ladezeit spürbar kürzer ist.  
+
+> [!TIP]  
+> Die größten Verbesserungen zeigen sich bei häufig geöffneten Workspaces,  
+> da Redis und PostgreSQL nun aktiv gecachte Daten wiederverwenden.
+
+👉 *Screenshot geeignet: Affine-Dashboard mit schneller Ladezeit nach Neustart.*
+
+Mit diesen Anpassungen ist dein Affine-System jetzt auf maximale Stabilität und Performance ausgelegt.  
+Alle Dienste – Datenbank, Cache und Anwendung – arbeiten effizient zusammen,  
+sodass du auch bei vielen Projekten, Aufgaben und Sponsorenübersichten  
+ein flüssiges, professionelles Arbeiten in deinem **Bratonien Creator Panel** behältst.
+
+## Abschluss & Ergebnis
+
+Mit diesem Premium-Kapitel hast du dein Affine-System auf ein professionelles Niveau gebracht.  
+Neben der Standardinstallation aus dem Hauptkapitel läuft Affine jetzt dauerhaft stabil, automatisch gesichert und mit optimaler Leistung.  
+Jeder Bereich – von der Datenbank bis zur Benutzeroberfläche – arbeitet harmonisch zusammen und erfordert keine manuelle Wartung mehr.
+
+> [!NOTE]  
+> Alle Optimierungen greifen direkt in der bestehenden Installation.  
+> Du musst nichts neu installieren oder wiederholen.  
+> Alle Skripte arbeiten selbstständig und sind so aufgebaut, dass sie bei Updates unverändert bleiben.
+
+### Zusammenfassung der Erweiterungen
+
+| Bereich | Erweiterung | Ergebnis |
+|----------|--------------|-----------|
+| **Vorlagen-Paket (Bratonien Creator Panel)** | Fertiger Workspace mit allen Bereichen für Creator | Sofort einsatzbereite Struktur |
+| **Automatische Datenbanksicherung** | Tägliches Backup inkl. Löschroutine | Schutz vor Datenverlust |
+| **Mail-Benachrichtigung** | E-Mail bei Erfolg oder Fehler | Volle Kontrolle ohne manuelles Prüfen |
+| **Workspace-Export & Archivierung** | JSON-Export mit Zeitstempel | Wiederherstellbare Workspaces |
+| **Healthcheck & Neustart** | Prüfung und Selbstheilung des Containers | Dauerhafte Verfügbarkeit |
+| **Manuelles Update-Skript** | Einfache Ausführung über Bash | Sicheres, kontrolliertes Updaten |
+| **Performance-Tuning** | Optimierte Werte für PostgreSQL & Redis | Spürbar schnelleres Arbeiten |
+
+> [!TIP]  
+> Alle Skripte findest du im Container unter `/usr/local/bin/`.  
+> Sie sind ausführbar und können bei Bedarf mit einem Texteditor angepasst werden.
+
+### Empfohlene Routine
+
+1. **Einmal pro Woche:** Logdateien prüfen  
+   ```bash
+   tail -n 20 /var/log/affine_backup.log
+   tail -n 20 /var/log/affine_export.log
+   ```
+2. **Einmal pro Monat:** Update-Skript starten  
+   ```bash
+   /usr/local/bin/affine_update.sh
+   ```
+3. **Nach größeren Änderungen:**  
+   Export und Datenbanksicherung manuell ausführen, um den aktuellen Stand zu sichern.
+
+> [!NOTE]  
+> Wenn du die Skripte regelmäßig verwendest, bleibt dein System dauerhaft stabil.  
+> Selbst bei einem kompletten Neustart des Containers stehen alle Daten und Workspaces sofort wieder zur Verfügung.
+
+👉 *Screenshot geeignet: Übersicht des Affine-Dashboards mit aktivem Bratonien Creator Panel, Systemstatus „Alles aktuell“ und grünem Haken.*