Kapitel 7/Free Rohtext.md hinzugefügt

2025-10-05 15:27:31 +00:00
parent b686a0f30e
commit 572945256b
1 changed files with 775 additions and 0 deletions
--- a/Rohtext.md
+++ b/Rohtext.md
@@ -0,0 +1,775 @@
+# 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.*