Thomas/Homelab--Bratonein-Kontrollzentrum--Tutorial

Files

Thomas Dannenberg a4cf79fbc6 Kapitel 7/Premium Rohtext.md hinzugefügt

2025-10-05 19:00:58 +00:00

29 KiB

Raw Blame History

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

Vorlagen-Paket für Affine
– fertige Workspaces, Boards und Dokumentstrukturen zur direkten Nutzung
Automatische Sicherung der PostgreSQL-Datenbank
– tägliche Backups inklusive Protokollierung und Aufbewahrungszeit
Mail-Benachrichtigung über Backup-Status
– automatische E-Mail bei Erfolg oder Fehler
Workspace-Export & Archivierung
– automatische JSON- oder ZIP-Exporte deiner Workspaces für das UCC-Archiv
Automatischer Container-Healthcheck & Neustart
– regelmäßige Prüfung und Selbstheilung des Affine-Stacks
Manuelles Update-Skript für Docker Compose
– einfache Befehlsausführung zur Aktualisierung aller Container
Performance-Tuning für PostgreSQL & Redis
– optimierte Konfigurationswerte für schnellere Reaktionszeiten
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

Lade die bereitgestellte JSON-Datei von der Premium-Downloadseite:
https://ucc.brationien.de/downloads/affine/bratonien-creator-panel.json
Öffne Affine → Workspaces → Import Workspace
Wähle die heruntergeladene Datei aus.
Der neue Bereich erscheint danach automatisch in der linken Seitenleiste.
Ö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:

nano /usr/local/bin/affine_backup.sh

Füge folgenden Inhalt ein:

#!/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:

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:

crontab -e

Am Ende hinzufügen:

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:

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:

tail -n 20 /var/log/affine_backup.log

Tip

Um das Backup sofort zu testen, führe das Skript manuell aus:
/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

Dienste stoppen, damit keine Schreibvorgänge stattfinden:
```
systemctl stop affine
systemctl stop postgresql
```
Backup-Verzeichnis prüfen:
```
ls -lh /mnt/hdd/affine_backups
```
Wähle die gewünschte Datei, z. B. db_2025-10-05_04-00.sql.

Datenbank wiederherstellen

PostgreSQL starten:
```
systemctl start postgresql
```

Alte Datenbank löschen und neu anlegen:

su - postgres
psql -c "DROP DATABASE affine;"
psql -c "CREATE DATABASE affine;"
psql -c "GRANT ALL PRIVILEGES ON DATABASE affine TO affine;"
exit

Sicherung einspielen:

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:

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:

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:

nano /usr/local/bin/affine_backup.sh

Ersetze den unteren Teil durch folgende erweiterte Version:

# 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:

/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
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:

nano /usr/local/bin/affine_export.sh

Füge folgenden Inhalt ein:

#!/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:

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:

crontab -e

Füge den folgenden Eintrag hinzu:

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:

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:

tail -n 20 /var/log/affine_export.log

Tip

Führe das Skript bei Bedarf manuell aus, um die Funktion sofort zu testen:
/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:

Entpacke das gewünschte Archiv auf deinem Computer.
Öffne in Affine das Menü Workspaces → Import Workspace.
Wähle die entpackte JSON-Datei aus.
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:

nano /usr/local/bin/affine_healthcheck.sh

Füge folgenden Inhalt ein:

#!/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:

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:

crontab -e

Füge am Ende der Datei hinzu:

*/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:

/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:

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:

nano /usr/local/bin/affine_update.sh

Füge folgenden Inhalt ein:

#!/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:

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:

/usr/local/bin/affine_update.sh

Während des Vorgangs werden alle Container neu gestartet und im Log protokolliert:

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:

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:

nano /etc/postgresql/16/main/postgresql.conf

Suche die folgenden Zeilen und ändere oder ergänze sie wie angegeben:

# 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:

systemctl restart postgresql

Zur Kontrolle:

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:

nano /etc/redis/redis.conf

Suche und passe folgende Werte an:

# 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:

systemctl restart redis-server

Überprüfen, ob Redis korrekt läuft:

redis-cli ping

Wenn PONG erscheint, funktioniert der Cache einwandfrei.

Wirkung prüfen

Öffne deinen Affine-Workspace im Browser.
Lade eine größere Seite oder Tabelle.
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

Einmal pro Woche: Logdateien prüfen

tail -n 20 /var/log/affine_backup.log
tail -n 20 /var/log/affine_export.log

Einmal pro Monat: Update-Skript starten
```
/usr/local/bin/affine_update.sh
```
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.

29 KiB Raw Blame History Unescape Escape

Kapitel 7 – Affine (Premium)

Einleitung

Themen dieses Kapitels

Vorlagen-Paket (Bratonien Creator Panel)

Ziel des Vorlagen-Pakets

Import des Workspaces

Inhalt des Vorlagen-Pakets

Platzhalter für die JSON-Datei

Automatische Sicherung der PostgreSQL-Datenbank

Ziel

Sicherungsskript anlegen

Automatische Ausführung einrichten

Ergebnis prüfen

Wiederherstellung eines Backups

Vorbereitung

Datenbank wiederherstellen

Neustart der Dienste

Funktionsprüfung

Mail-Benachrichtigung über Backup-Status

Ziel

Mail-System installieren

Skript anpassen

Funktion testen

Workspace-Export & Archivierung

Ziel

Export-Skript anlegen

Automatische Ausführung einrichten

Ergebnis prüfen

Sicherung verwenden

Wiederherstellung eines Workspace-Exports

Automatischer Container-Healthcheck & Neustart

Ziel

Healthcheck-Skript anlegen

Automatische Ausführung einrichten

Funktion prüfen

Logdatei prüfen

Manuelles Update-Skript für Docker Compose

Ziel

Update-Skript anlegen

Update ausführen

Fehlerbehebung

Performance-Tuning für PostgreSQL & Redis

Ziel

PostgreSQL optimieren

Redis optimieren

Wirkung prüfen

Abschluss & Ergebnis

Zusammenfassung der Erweiterungen

Empfohlene Routine

29 KiB

Raw Blame History