Homelab--Bratonein-Kontrollzentrum--Tutorial/Kapitel 07/Free Rohtext.md

# Kapitel 7 – Affine (Open-Source Notion-Alternative)

Affine ist eine vollständig selbst gehostete Plattform für Notizen, Aufgaben, Whiteboards und Projekte – eine private Alternative zu Diensten wie Notion, Miro oder ClickUp.  
Sie läuft auf deinem eigenen UCC-Server und speichert alle Daten ausschließlich unter deiner Kontrolle.

Für Content Creator, Streamer und kleine Teams ist Affine ideal:  
Du kannst Ideen sammeln, Projekte planen, Redaktionsabläufe organisieren und gemeinsam an Inhalten arbeiten – alles ohne externe Anbieter.

> [!TIP]  
> Affine vereint klassische Textverarbeitung, Whiteboard-Visualisierung und Tabellen in einem System.  
> So kannst du deine Planung, Notizen und Konzepte direkt in einem zentralen Workspace verwalten.

### Ziel dieses Kapitels

Wir installieren Affine in einem eigenen **Debian 12 LXC-Container** und kombinieren zwei wichtige Komponenten:

- **PostgreSQL** als Datenbank für Projekte, Dokumente und Workspaces  
- **Redis** für schnellen Cache und Hintergrundprozesse

Anschließend binden wir die Instanz über den **Nginx Proxy Manager (NPM)** sicher an deine Domain an und aktivieren die Weboberfläche für mehrere Benutzer.  
So entsteht ein vollständiger Notiz- und Projektarbeitsbereich, der auf jedem Gerät erreichbar ist – übersichtlich, stabil und unter deiner Kontrolle.

> [!NOTE]  
> Wir bauen hier direkt auf den Grundlagen aus den vorherigen Kapiteln auf.  
> Du brauchst also keine neuen Tools, nur denselben Proxmox-Host, den du bereits nutzt.

👉 *Screenshot geeignet: Affine-Dashboard mit geöffnetem Board und Dokumentenansicht.*

## Voraussetzungen & Ressourcen

Affine ist eine moderne, aber ressourcenschonende Plattform.  
Damit alle Funktionen – Dokumente, Boards und Datenbankzugriffe – zuverlässig arbeiten, sollte der Container eine stabile Basis bieten.

### Anforderungen an den Container

- **Betriebssystem:** Debian 12 (Bookworm)  
  Debian ist schlank, stabil und hervorragend für LXC-Container geeignet.  
- **CPU:** 2 Kerne  
- **RAM:** 4 GB  
- **Speicherplatz:** 20 GB  
- **Netzwerk:** Statische IPv4-Adresse per DHCP-Reservierung, z. B. `192.168.1.70`

> [!TIP]  
> Weise die IP-Adresse im Router per **DHCP-Reservierung** zu.  
> So bleibt sie dauerhaft gleich und verhindert Konflikte mit automatisch vergebenen Adressen.

> [!NOTE]  
> Affine benötigt keine zusätzliche Datenplatte.  
> Alle Inhalte werden in der Datenbank (PostgreSQL) und im Cache (Redis) gespeichert.  
> Wenn du nicht sicher bist, wie du einen LXC-Container anlegst,  
> findest du die vollständige Anleitung in **Kapitel 2 – Pi-hole + Unbound**.

👉 *Screenshot geeignet: Proxmox-Maske „Neuen LXC erstellen“ mit aktivierter Option „Nesting“.*

---

### Voraussetzungen im UCC

Affine wird später über den bereits eingerichteten **Nginx Proxy Manager (NPM)** erreichbar gemacht.  
Dieser übernimmt die SSL-Verschlüsselung und die Verbindung zwischen Internet und deiner Affine-Instanz.  
Für dieses Kapitel genügt es, wenn der Proxy bereits läuft und deine Domain erreichbar ist.

> [!NOTE]  
> Die konkrete Einrichtung des Proxy Hosts erfolgt im Hauptteil des Tutorials,  
> sobald der Container fertig installiert und Affine lokal erreichbar ist.

👉 *Screenshot geeignet: UCC-Strukturübersicht mit NPM-Container und geplantem Affine-LXC.*

### Dienste im Überblick

Im Container installieren wir zwei zentrale Dienste:

1. **PostgreSQL** – Datenbank für Projekte, Dokumente und Workspaces  
2. **Redis** – Cache und Synchronisations-Backend für schnelle Zugriffe

Diese beiden Komponenten bilden die technische Basis für eine stabile Affine-Instanz.

> [!NOTE]  
> Redis beschleunigt die Bearbeitung und ermöglicht gleichzeitige Zugriffe auf gemeinsame Boards,  
> ohne dass es zu Datei-Sperren oder Datenkonflikten kommt.

👉 *Screenshot geeignet: Diagramm mit Verbindung Affine ↔ Redis + PostgreSQL.*

---

## Schritt für Schritt

Bevor wir mit der eigentlichen Installation beginnen, stellen wir sicher, dass der Container bereit ist und alle Systempakete aktuell sind.  
Alle folgenden Befehle werden **direkt im Container-Terminal** ausgeführt.

### System aktualisieren

Führe die Aktualisierung aus:

```bash
apt update && apt upgrade -y
```

> [!NOTE]  
> Dieser Schritt stellt sicher, dass alle installierten Pakete auf dem neuesten Stand sind.  
> Führe ihn immer vor neuen Installationen aus, um Versionskonflikte zu vermeiden.

👉 *Screenshot geeignet: Terminal mit abgeschlossener Paketaktualisierung.*

### Basis-Tools installieren

Einige Werkzeuge werden für Docker, PostgreSQL und Redis benötigt.  
Installiere sie in einem Schritt:

```bash
apt install -y curl gnupg2 ca-certificates lsb-release apt-transport-https software-properties-common unzip nano sudo
```

> [!TIP]  
> Diese Tools sind systemweit nützlich – du kannst sie auch in anderen Containern wiederverwenden.

👉 *Screenshot geeignet: Terminal mit erfolgreicher Installation der Basis-Tools.*

### Docker installieren

Affine wird über Docker Compose betrieben.  
Damit Docker im Container korrekt funktioniert, richten wir zunächst das offizielle Repository ein und installieren anschließend die Pakete.

```bash
# Docker GPG-Schlüssel importieren
curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Repository hinzufügen
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] \
https://download.docker.com/linux/debian $(lsb_release -cs) stable" \
> /etc/apt/sources.list.d/docker.list

# Paketlisten aktualisieren und Docker installieren
apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```

> [!NOTE]  
> Nach der Installation steht der Befehl `docker compose` systemweit zur Verfügung.  
> Damit können mehrere Dienste – wie Affine, PostgreSQL und Redis – gemeinsam gestartet werden.

👉 *Screenshot geeignet: Terminal mit installierten Docker-Paketen.*

### Docker-Dienst aktivieren und prüfen

Starte und aktiviere den Docker-Dienst:

```bash
systemctl enable --now docker
```

Prüfe anschließend die Installation:

```bash
docker --version
docker compose version
```

Wenn beide Befehle Versionen ausgeben, läuft Docker korrekt.  
Docker startet künftig automatisch beim Hochfahren des Containers – du musst ihn nicht manuell aktivieren.

👉 *Screenshot geeignet: Terminal mit erfolgreicher Docker-Versionsanzeige.*

### Verzeichnisstruktur für Affine anlegen

Affine wird in einem eigenen Anwendungsverzeichnis betrieben.  
Dort liegen später die Docker-Konfigurationsdateien und Datenbanken.

```bash
mkdir -p /srv/affine
cd /srv/affine
```

> [!NOTE]  
> In diesem Verzeichnis legen wir gleich die `docker-compose.yml` ab,  
> über die Affine, PostgreSQL und Redis gemeinsam gestartet werden.

👉 *Screenshot geeignet: Dateistruktur /srv/affine im Terminal.

### Docker-Compose-Datei erstellen und Affine installieren

Affine wird zusammen mit PostgreSQL und Redis in Containern betrieben.  
Alle Dienste lassen sich über eine einzige `docker-compose.yml` steuern.  
Wir legen sie jetzt an und konfigurieren sie Schritt für Schritt.

Wechsle in das Arbeitsverzeichnis und öffne den Editor:

```bash
cd /srv/affine
nano docker-compose.yml
```

Füge folgenden Inhalt ein:

```yaml
version: "3.9"

services:
  affine:
    image: ghcr.io/toeverything/affine-graphql:stable
    container_name: affine
    restart: unless-stopped
    depends_on:
      - db
      - redis
    ports:
      - "3000:3000"
    environment:
      - AFFINE_SERVER_PORT=3000
      - DATABASE_URL=postgresql://affine:DEIN_SICHERES_PASSWORT@db:5432/affine
      - REDIS_URL=redis://redis:6379
    volumes:
      - affine_data:/app/.affine

  db:
    image: postgres:16
    container_name: affine_db
    restart: unless-stopped
    environment:
      - POSTGRES_DB=affine
      - POSTGRES_USER=affine
      - POSTGRES_PASSWORD=DEIN_SICHERES_PASSWORT
    volumes:
      - db_data:/var/lib/postgresql/data

  redis:
    image: redis:7
    container_name: affine_redis
    restart: unless-stopped
    volumes:
      - redis_data:/data

volumes:
  affine_data:
  db_data:
  redis_data:
```

> [!NOTE]  
> Ersetze `DEIN_SICHERES_PASSWORT` an beiden Stellen durch ein starkes Passwort mit Sonderzeichen.  
> Dieses Passwort sichert sowohl die Datenbank als auch den internen Zugriff des Affine-Servers auf PostgreSQL.

Speichern mit **Strg + O**, bestätigen mit **Enter**, schließen mit **Strg + X**.

👉 *Screenshot geeignet: Editor mit vollständiger docker-compose.yml.*

### Container starten

Starte anschließend alle Dienste:

```bash
docker compose up -d
```

Docker lädt die benötigten Images und startet die Container automatisch.  
Der erste Start kann einige Minuten dauern, da mehrere Abhängigkeiten eingerichtet werden.

> [!TIP]  
> Mit `docker compose ps` kannst du jederzeit prüfen, ob alle Dienste laufen.  
> In der Spalte „State“ sollte bei allen Containern „running“ stehen.

👉 *Screenshot geeignet: Terminal mit Ausgabe von docker compose ps.*

### Funktion prüfen

Öffne im Browser die Adresse deines Servers:

```
http://192.168.1.70:3000
```

Es sollte die Willkommensseite von **Affine** erscheinen.

> [!NOTE]  
> Wenn die Seite nicht geladen wird, überprüfe mit  
> ```bash
> docker compose logs affine
> ```  
> ob der Dienst fehlerfrei gestartet wurde.

👉 *Screenshot geeignet: Browserfenster mit Affine-Startseite.*

### Affine im Nginx Proxy Manager einrichten

Affine ist nun lokal im Container über Port 3000 erreichbar.  
Damit du die Anwendung auch verschlüsselt über deine Domain aufrufen kannst,  
richten wir im **Nginx Proxy Manager (NPM)** einen neuen Proxy Host ein.

#### Anmeldung im Dashboard

Öffne im Browser das NPM-Dashboard:

```
https://proxy.DEINE-DOMAIN.tld
```

Alternativ kannst du dich auch über die interne IP deines Proxy-Containers anmelden:

```
http://192.168.1.10:81
```

Melde dich mit deinem Administrator-Konto an.  
Im Menü klickst du links auf **Hosts → Proxy Hosts**  
und anschließend oben rechts auf **Add Proxy Host**.

👉 *Screenshot geeignet: NPM-Dashboard mit geöffnetem Menü „Proxy Hosts“.*

#### Proxy Host anlegen

Trage die Daten wie folgt ein:

| Feld | Wert |
|------|------|
| **Domain Names** | `affine.DEINE-DOMAIN.tld` |
| **Scheme** | `http` |
| **Forward Hostname / IP** | IP-Adresse des Affine-Containers, z. B. `192.168.1.70` |
| **Forward Port** | `3000` |
| **Block Common Exploits** | ✅ aktiviert |
| **Websockets Support** | ✅ aktiviert |

> [!NOTE]  
> Affine läuft intern über HTTP auf Port 3000.  
> Der Proxy Manager übernimmt die HTTPS-Verschlüsselung und kümmert sich automatisch um das Zertifikat.

👉 *Screenshot geeignet: ausgefüllte Proxy-Maske mit Beispielwerten.*

#### SSL-Zertifikat erstellen

Wechsle in den Reiter **SSL**  
und wähle **Request a new SSL Certificate**.

1. Aktiviere folgende Optionen:  
   - ✅ Force SSL  
   - ✅ HTTP/2 Support  
   - ✅ HSTS (optional, empfohlen)
2. Gib deine E-Mail-Adresse ein (für Let’s Encrypt).
3. Klicke auf **Save**.

Nach wenigen Sekunden erscheint das Zertifikat mit dem Status *Active*.

> [!TIP]  
> Falls die Zertifikatserstellung fehlschlägt, prüfe,  
> ob Port 80 und 443 in deiner Firewall und im Router korrekt weitergeleitet sind  
> und die Domain auf die öffentliche IP deines UCC zeigt.

👉 *Screenshot geeignet: SSL-Reiter mit aktiviertem Let’s-Encrypt-Zertifikat.*

#### Erweiterte Einstellungen

Affine kann große Datenmengen und komplexe Whiteboards verarbeiten.  
Damit der Proxy keine Timeouts verursacht, erweitern wir die Standardwerte.

1. Öffne beim selben Proxy Host den Reiter **Advanced**.  
2. Füge folgenden Text ein:

```nginx
client_max_body_size 10G;
proxy_read_timeout 3600;
proxy_send_timeout 3600;
```

3. Klicke auf **Save**.

> [!NOTE]  
> Diese Werte verhindern Abbrüche bei größeren Dokumenten, Importen oder längeren Sitzungen.

👉 *Screenshot geeignet: Reiter „Advanced“ mit eingetragenen Timeout-Werten.*

#### Verbindung prüfen

Öffne im Browser:

```
https://affine.DEINE-DOMAIN.tld
```

Wenn alles korrekt eingerichtet ist, erscheint das Anmeldefenster bzw. die Startseite von Affine.  
Damit ist der externe Zugriff über den Proxy erfolgreich hergestellt.

> [!TIP]  
> Sollte stattdessen eine Fehlermeldung oder eine Nginx-Standardseite erscheinen,  
> prüfe, ob **Forward Hostname/IP** und **Port 3000** richtig eingetragen sind  
> und die Domain auf den NPM-Server zeigt.

👉 *Screenshot geeignet: Browserfenster mit geöffneter Affine-Oberfläche über HTTPS.*

### Ersteinrichtung & Benutzerkonto anlegen

Nachdem die Verbindung über den Proxy funktioniert, kannst du Affine direkt im Browser einrichten.  
Öffne dazu die Adresse deiner Instanz:

```
https://affine.DEINE-DOMAIN.tld
```

Nach kurzer Ladezeit erscheint die Startseite von Affine mit der Aufforderung, ein erstes Konto zu erstellen.

👉 *Screenshot geeignet: Browserfenster mit Affine-Anmeldemaske.*

#### Erstes Benutzerkonto erstellen

Trage deine gewünschten Zugangsdaten ein:

| Feld | Beschreibung |
|------|--------------|
| **E-Mail-Adresse** | dient als Benutzername und zur Anmeldung |
| **Passwort** | ein sicheres Kennwort mit Sonderzeichen |
| **Workspace-Name** | frei wählbar, z. B. `UCC Projekte` |

Klicke anschließend auf **Create Account** oder **Register**.

> [!TIP]  
> Verwende eine gültige E-Mail-Adresse, auch wenn du keine E-Mail-Bestätigung erhältst.  
> Sie dient später zur Anmeldung und kann für Benachrichtigungen genutzt werden,  
> sobald du einen Mail-Dienst angebunden hast.

👉 *Screenshot geeignet: Formular mit ausgefüllten Feldern.*

#### Anmeldung im Dashboard

Nach der Registrierung wirst du automatisch in dein Dashboard weitergeleitet.  
Hier siehst du deinen ersten Workspace, eine leere Startseite und die linke Navigationsleiste mit den Bereichen:

- **Docs** – klassische Textdokumente mit Überschriften, Listen und Medien  
- **Whiteboards** – visuelle Notizen und Planungen  
- **Database / Tables** – strukturierte Datensammlungen (z. B. Projektlisten oder Aufgaben)  
- **Settings** – Benutzer- und Workspace-Einstellungen

> [!NOTE]  
> Die Free-Version von Affine unterstützt mehrere Workspaces,  
> aber keine geteilten Benutzerkonten mit erweiterten Berechtigungen.  
> Diese Funktionen sind der späteren Premium-Version vorbehalten.

👉 *Screenshot geeignet: Affine-Dashboard nach der Ersteinrichtung.*

#### Grundeinstellungen prüfen

Bevor du beginnst, Inhalte zu erstellen, prüfe die Basiskonfiguration.

1. Öffne links das Menü **Settings → System**.  
2. Überprüfe, ob die Verbindung zu **PostgreSQL** und **Redis** aktiv ist.  
   Beide sollten als *Connected* angezeigt werden.  
3. Unter **About** kannst du die aktuelle Version und Build-Nummer sehen.

> [!TIP]  
> Wenn einer der Dienste als „Disconnected“ angezeigt wird,  
> starte die Container neu:
> ```bash
> docker compose restart
> ```
> In der Regel behebt das Verbindungsprobleme sofort.

👉 *Screenshot geeignet: Einstellungen-Seite mit aktiven Diensten.*

Damit ist Affine vollständig eingerichtet und einsatzbereit.  
Im nächsten Schritt richten wir optionale Synchronisationsfunktionen und den automatischen Neustart des Containers ein.

### Affine verwenden – Grundlagen der Oberfläche

Nach der Ersteinrichtung kannst du Affine sofort nutzen.  
Die Oberfläche ist klar strukturiert und ähnelt bekannten Tools wie Notion oder Miro.  
Wir gehen jetzt die wichtigsten Bereiche durch, um dir den Einstieg zu erleichtern.

#### Aufbau der Oberfläche

Die Benutzeroberfläche besteht aus drei Hauptbereichen:

1. **Linke Seitenleiste** – Navigation zwischen Workspaces, Dokumenten und Boards  
2. **Arbeitsbereich** – zentrale Fläche, auf der du schreibst, zeichnest oder planst  
3. **Obere Menüleiste** – Aktionen wie Speichern, Teilen oder Ansicht wechseln

👉 *Screenshot geeignet: Affine-Hauptfenster mit markierten Bereichen.*

> [!NOTE]  
> Die Oberfläche ist vollständig webbasiert.  
> Änderungen werden automatisch gespeichert, sobald du tippst oder ein Element verschiebst.  
> Ein manuelles Speichern ist nicht nötig.

#### Neues Dokument anlegen

Um ein neues Dokument zu erstellen, klickst du in der linken Seitenleiste auf **New Doc** oder das **Plus-Symbol**.  
Im Arbeitsbereich öffnet sich eine leere Seite.  
Du kannst direkt mit dem Schreiben beginnen oder Textblöcke hinzufügen.

**Wichtige Funktionen:**
- **Überschrift hinzufügen:** `#` + Leertaste  
- **Liste erstellen:** `-` + Leertaste  
- **Checkliste:** `[ ]` + Leertaste  
- **Trennlinie:** `---`  
- **Befehlspalette:** `/` öffnet alle verfügbaren Block-Typen

👉 *Screenshot geeignet: Beispielseite mit Text, Liste und Überschrift.*

> [!TIP]  
> Du kannst Blöcke jederzeit verschieben, indem du links neben dem Text auf die sechs Punkte klickst  
> und sie per Drag-and-Drop an eine andere Stelle ziehst.

#### Whiteboards nutzen

Affine kombiniert Textdokumente und Whiteboards im selben Workspace.  
Um in den visuellen Modus zu wechseln, klickst du oben rechts auf **Edgeless**.  

Jetzt kannst du frei zeichnen, Formen platzieren, Textfelder anlegen oder Notizen verbinden.

**Nützliche Aktionen:**
- Formen hinzufügen: `O` für Kreise, `R` für Rechtecke  
- Textfeld erstellen: `T`  
- Linien und Pfeile ziehen: `L`  
- Zoomen: `Strg + Mausrad` oder Touch-Gesten  
- Rückgängig machen: `Strg + Z`

👉 *Screenshot geeignet: Offenes Whiteboard mit Notizen und Pfeilen.*

> [!NOTE]  
> Alle Inhalte – Text und Grafiken – werden automatisch gespeichert.  
> Du kannst jederzeit zurück in die Dokumentansicht wechseln, ohne Daten zu verlieren.

#### Tabellen und Listen

Affine bietet einfache Tabellen- und Datenbankfunktionen.  
Damit kannst du z. B. Redaktionspläne, Stream-Ideen oder To-Do-Listen verwalten.

Klicke auf **New Table**, gib Spaltennamen ein und wähle den Datentyp (Text, Zahl, Datum, Auswahl).  
Neue Zeilen fügst du über das Plus-Symbol unterhalb der Tabelle hinzu.

> [!TIP]  
> Tabellen lassen sich in Dokumente einbetten oder auf einem Whiteboard verknüpfen.  
> So kannst du Projektlisten visuell darstellen oder mit Textnotizen kombinieren.

👉 *Screenshot geeignet: Beispiel-Tabelle mit Projektnamen und Status-Spalte.*

#### Eigenes Dashboard erstellen

Ein Dashboard ist eine Übersichtsseite mit deinen wichtigsten Informationen und Verknüpfungen.  
So kannst du dir z. B. ein **Content-Planungs-Dashboard** oder eine **Projektübersicht** bauen.

1. Erstelle ein neues Dokument mit dem Titel `Dashboard`.  
2. Füge mit `/table` eine oder mehrere Tabellen ein – z. B. eine Liste deiner Projekte.  
3. Füge darüber eine Textüberschrift hinzu, z. B. `# UCC Übersicht`.  
4. Mit `/link to page` kannst du direkt auf andere Dokumente oder Whiteboards verweisen.  
5. Optional kannst du Emojis oder Icons vor Überschriften setzen, um Kategorien visuell zu trennen.

> [!TIP]  
> Nutze Tabellen als interaktive Listen:  
> - Spalte **Status** mit Optionen wie „In Arbeit“, „Fertig“, „Geplant“  
> - Spalte **Typ** für die Kategorie (z. B. Video, Stream, Blogpost)  
> - Spalte **Veröffentlichung** als Datum  
>  
> So kannst du dein Dashboard wie eine kleine Redaktionsplanung verwenden.

👉 *Screenshot geeignet: Beispiel-Dashboard mit Tabelle und internen Verknüpfungen.*

#### Ansichten und Filter

Affine erlaubt es, Tabellen nach Bedarf zu filtern oder zu sortieren.  
Damit kannst du z. B. nur geplante Projekte oder abgeschlossene Aufgaben anzeigen.

1. Öffne eine Tabelle.  
2. Klicke oben auf **Filter → Add Filter**.  
3. Wähle die Spalte und Bedingung, z. B. `Status = In Arbeit`.  
4. Du kannst mehrere Filter kombinieren oder eine eigene Ansicht speichern.

> [!NOTE]  
> Diese Funktion entspricht der Ansichtsauswahl in Notion.  
> Jede gespeicherte Ansicht kann unterschiedliche Filter, Sortierungen und Layouts enthalten.

👉 *Screenshot geeignet: Tabelle mit aktivem Filter-Menü.*

#### Arbeiten mit Workspaces

Ein Workspace ist der zentrale Arbeitsbereich in Affine.  
Er enthält deine Dokumente, Boards und Tabellen.

- Standardmäßig wird beim ersten Start ein Workspace erstellt.  
- Weitere Workspaces kannst du über das Menü **Switch Workspace → New Workspace** anlegen.  
- Jeder Workspace ist unabhängig und hat eigene Berechtigungen und Inhalte.

> [!NOTE]  
> In der Free-Version ist die Anzahl der Workspaces begrenzt,  
> sie reicht jedoch für den persönlichen oder kreativen Gebrauch vollständig aus.

👉 *Screenshot geeignet: Workspace-Übersicht mit mehreren Projekten.*

Damit kennst du die Grundfunktionen von Affine und kannst eigene Dashboards, Projektlisten und Boards anlegen.  
Im nächsten Abschnitt gehen wir auf häufige Probleme, Systemmeldungen und deren Lösungen ein.

---
## Troubleshooting & Tipps

Nach der Einrichtung kann es in Affine zu kleineren Problemen oder Warnmeldungen kommen.  
In diesem Abschnitt gehen wir auf typische Ursachen und deren Lösungen ein.

### Container starten nicht korrekt

Wenn nach einem Neustart des LXC einer oder mehrere Container nicht laufen, prüfe zunächst den Status:

```bash
cd /srv/affine
docker compose ps
```

In der Spalte **State** sollte bei allen Einträgen *running* stehen.  
Wenn ein Dienst mit *exited* oder *restarting* angezeigt wird, überprüfe die Logs:

```bash
docker compose logs affine
docker compose logs db
docker compose logs redis
```

> [!NOTE]  
> Häufigste Ursache ist ein falsch gesetztes Passwort in der `docker-compose.yml`.  
> PostgreSQL verweigert dann die Verbindung.  
> Öffne in diesem Fall die Datei erneut und prüfe die Passwörter.

👉 *Screenshot geeignet: Terminal mit Ausgabe von docker compose ps.*

### Zugriff im Browser nicht möglich

Wenn du Affine über `https://affine.DEINE-DOMAIN.tld` nicht erreichst,  
teste zuerst den direkten Zugriff auf den Container:

```
http://192.168.1.70:3000
```

Wenn die Seite lokal funktioniert, liegt das Problem meist im **Nginx Proxy Manager**.

1. Öffne den Proxy Host in NPM.  
2. Prüfe, ob die **IP-Adresse** und der **Port 3000** korrekt eingetragen sind.  
3. Kontrolliere im Reiter **SSL**, ob das Zertifikat aktiv ist.  
4. Speichere den Eintrag erneut und teste die Domain nach wenigen Minuten.

> [!TIP]  
> Wenn die Domain zwar lädt, aber nur eine leere Seite zeigt,  
> hilft häufig ein Browser-Cache-Reset (Strg + F5).

👉 *Screenshot geeignet: Proxy-Host-Maske mit korrekten Einträgen.*

### Änderungen werden nicht gespeichert

Affine speichert Inhalte automatisch, sobald du sie änderst.  
Wenn neue Dokumente oder Boards nach einem Neustart fehlen,  
ist meist das Volume für die App-Daten nicht korrekt eingebunden.

Prüfe im Container:

```bash
docker volume ls
```

In der Liste müssen die Volumes `affine_affine_data`, `affine_db_data` und `affine_redis_data` vorhanden sein.  
Falls eines fehlt, starte die Container komplett neu:

```bash
docker compose down
docker compose up -d
```

> [!NOTE]  
> Docker legt fehlende Volumes automatisch wieder an.  
> Bereits vorhandene Inhalte bleiben erhalten.

👉 *Screenshot geeignet: Terminal mit docker volume ls.*

### Datenbankfehler oder „connection refused“

Wenn Affine beim Start eine Fehlermeldung wie  
`database connection failed` anzeigt, ist die Verbindung zu PostgreSQL unterbrochen.

Führe folgende Prüfung aus:

```bash
docker exec -it affine_db pg_isready
```

Wenn die Ausgabe `accepting connections` lautet, ist die Datenbank aktiv.  
Andernfalls hilft ein Neustart:

```bash
docker compose restart db
```

> [!TIP]  
> In seltenen Fällen ist das Volume beschädigt.  
> Du kannst die Datenbank neu anlegen, indem du die Container stoppst,  
> das Volume `affine_db_data` löschst und die Container erneut startest.  
> Die App legt dann eine frische leere Datenbank an.

👉 *Screenshot geeignet: Terminal mit pg_isready-Ausgabe.*

### Container regelmäßig neu starten

Wenn Affine nach längerer Laufzeit träge reagiert oder Speicherprobleme zeigt,  
hilft ein periodischer Neustart der Container.  
Das ist kein Fehler, sondern normales Wartungsverhalten bei Web-Anwendungen.

Führe diesen Befehl aus, um alle Container neu zu starten:

```bash
cd /srv/affine
docker compose restart
```

> [!NOTE]  
> Dadurch bleiben alle Daten erhalten.  
> Nur der Arbeitsspeicher wird freigegeben, was die Performance verbessert.

👉 *Screenshot geeignet: Terminal mit Neustart-Ausgabe.*

### Updates installieren

Affine wird regelmäßig aktualisiert.  
Um auf die neueste Version zu wechseln, führe im Container folgende Befehle aus:

```bash
cd /srv/affine
docker compose pull
docker compose up -d
```

> [!TIP]  
> `docker compose pull` lädt nur neue Versionen herunter,  
> ohne die bestehenden Daten zu löschen.  
> So kannst du sicher aktualisieren, ohne den Workspace zu verlieren.

👉 *Screenshot geeignet: Terminal mit erfolgreichem Update-Vorgang.*

Damit bist du auf typische Situationen vorbereitet und kannst Affine im laufenden Betrieb warten.  
Im nächsten Abschnitt folgt die Zusammenfassung und der Ausblick auf die nächsten Schritte.

## Zusammenfassung & Nächste Schritte

Mit diesem Kapitel hast du eine vollständig funktionsfähige Affine-Instanz eingerichtet –  
von der Installation über Docker bis hin zur sicheren Bereitstellung über den Nginx Proxy Manager.

Du hast gelernt:

- wie du einen eigenen **Debian 12 LXC-Container** für Affine vorbereitest  
- wie du **Docker Compose** installierst und eine gemeinsame Umgebung mit PostgreSQL und Redis aufbaust  
- wie du Affine über den **Nginx Proxy Manager** sicher mit HTTPS veröffentlichst  
- wie du Benutzerkonten, Dokumente, Whiteboards und Tabellen anlegst  
- wie du eigene Dashboards und Ansichten erstellst, um Projekte zu strukturieren  
- wie du häufige Fehler erkennst und behebst  

Damit steht dir jetzt ein zentraler Arbeitsbereich im UCC zur Verfügung,  
mit dem du Notizen, Planungen und Projektideen unabhängig von Cloud-Diensten verwalten kannst.

> [!TIP]  
> Du kannst Affine jederzeit über deinen Browser öffnen:  
> **https://affine.DEINE-DOMAIN.tld**  
>  
> Änderungen werden automatisch gespeichert – es ist kein manuelles Speichern notwendig.  
>  
> Für den Zugriff im Heimnetz kannst du in Nginx Proxy Manager eine Access-List mit lokalen IP-Bereichen anlegen.

👉 *Screenshot geeignet: Affine-Dashboard mit geöffnetem Dokument und aktiver Verbindung über HTTPS.*

### Ausblick

Im nächsten Kapitel geht es um das **Archiv** – den zentralen Speicherort deines UCC-Systems.  
Hier legst du fest, wie Daten aus Nextcloud, Affine und zukünftigen Diensten dauerhaft aufbewahrt werden.  
Damit schaffst du eine klare Trennung zwischen aktiver Nutzung und langfristiger Sicherung.

Das Archiv dient als Grundlage für Backups, Versionierung und strukturierte Ablage.  
So bleibt dein System auch bei wachsender Datenmenge übersichtlich,  
und du kannst jederzeit nachvollziehen, wo sich welche Inhalte befinden.

> [!NOTE]  
> Das Archiv ist der nächste logische Schritt im Aufbau deines UCC.  
> Es sorgt dafür, dass deine gespeicherten Dokumente, Boards und Projekte  
> langfristig sicher und zentral verwaltet werden.

👉 *Screenshot geeignet: UCC-Dashboard mit markierten Containern Nextcloud, Affine und Archiv.*