From a4cf79fbc6172d1396a913ca00767a554df7a410 Mon Sep 17 00:00:00 2001 From: Thomas Dannenberg Date: Sun, 5 Oct 2025 19:00:58 +0000 Subject: [PATCH] =?UTF-8?q?Kapitel=207/Premium=20Rohtext.md=20hinzugef?= =?UTF-8?q?=C3=BCgt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Kapitel 7/Premium Rohtext.md | 928 +++++++++++++++++++++++++++++++++++ 1 file changed, 928 insertions(+) create mode 100644 Kapitel 7/Premium Rohtext.md diff --git a/Kapitel 7/Premium Rohtext.md b/Kapitel 7/Premium Rohtext.md new file mode 100644 index 0000000..332ca34 --- /dev/null +++ b/Kapitel 7/Premium 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.*