Thomas/Homelab--Bratonein-Kontrollzentrum--Tutorial

Files

Thomas Dannenberg 572945256b Kapitel 7/Free Rohtext.md hinzugefügt

2025-10-05 15:27:31 +00:00

27 KiB

Raw Blame History

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:

PostgreSQL – Datenbank für Projekte, Dokumente und Workspaces
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:

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:

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.

# 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:

systemctl enable --now docker

Prüfe anschließend die Installation:

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.

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:

cd /srv/affine
nano docker-compose.yml

Füge folgenden Inhalt ein:

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:

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

Aktiviere folgende Optionen:
- ✅ Force SSL
- ✅ HTTP/2 Support
- ✅ HSTS (optional, empfohlen)
Gib deine E-Mail-Adresse ein (für Let’s Encrypt).
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.

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

client_max_body_size 10G;
proxy_read_timeout 3600;
proxy_send_timeout 3600;

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.

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

Tip

Wenn einer der Dienste als „Disconnected“ angezeigt wird,
starte die Container neu:
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:

Linke Seitenleiste – Navigation zwischen Workspaces, Dokumenten und Boards
Arbeitsbereich – zentrale Fläche, auf der du schreibst, zeichnest oder planst
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.

Erstelle ein neues Dokument mit dem Titel Dashboard.
Füge mit /table eine oder mehrere Tabellen ein – z. B. eine Liste deiner Projekte.
Füge darüber eine Textüberschrift hinzu, z. B. # UCC Übersicht.
Mit /link to page kannst du direkt auf andere Dokumente oder Whiteboards verweisen.
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.

Öffne eine Tabelle.
Klicke oben auf Filter → Add Filter.
Wähle die Spalte und Bedingung, z. B. Status = In Arbeit.
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:

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:

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.

Öffne den Proxy Host in NPM.
Prüfe, ob die IP-Adresse und der Port 3000 korrekt eingetragen sind.
Kontrolliere im Reiter SSL, ob das Zertifikat aktiv ist.
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:

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:

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:

docker exec -it affine_db pg_isready

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

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:

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:

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.

27 KiB Raw Blame History Unescape Escape

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

Ziel dieses Kapitels

Voraussetzungen & Ressourcen

Anforderungen an den Container

Voraussetzungen im UCC

Dienste im Überblick

Schritt für Schritt

System aktualisieren

Basis-Tools installieren

Docker installieren

Docker-Dienst aktivieren und prüfen

Verzeichnisstruktur für Affine anlegen

Docker-Compose-Datei erstellen und Affine installieren

Container starten

Funktion prüfen

Affine im Nginx Proxy Manager einrichten

Anmeldung im Dashboard

Proxy Host anlegen

SSL-Zertifikat erstellen

Erweiterte Einstellungen

Verbindung prüfen

Ersteinrichtung & Benutzerkonto anlegen

Erstes Benutzerkonto erstellen

Anmeldung im Dashboard

Grundeinstellungen prüfen

Affine verwenden – Grundlagen der Oberfläche

Aufbau der Oberfläche

Neues Dokument anlegen

Whiteboards nutzen

Tabellen und Listen

Eigenes Dashboard erstellen

Ansichten und Filter

Arbeiten mit Workspaces

Troubleshooting & Tipps

Container starten nicht korrekt

Zugriff im Browser nicht möglich

Änderungen werden nicht gespeichert

Datenbankfehler oder „connection refused“

Container regelmäßig neu starten

Updates installieren

Zusammenfassung & Nächste Schritte

Ausblick

27 KiB

Raw Blame History