diff --git a/Kapitel 7/Free Rohtext.md b/Kapitel 7/Free Rohtext.md new file mode 100644 index 0000000..1d22194 --- /dev/null +++ b/Kapitel 7/Free 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.* \ No newline at end of file