929 lines
29 KiB
Markdown
929 lines
29 KiB
Markdown
# 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.*
|