# 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.*