Die Open-Source-Plattform AFFiNE Community Edition (CE) ist eine leistungsfähige, lokal hostbare Alternative zu Tools wie Notion, Miro oder Obsidian. Mit AFFiNE kannst du Notizen, Tabellen, Whiteboards und Diagramme in einer einheitlichen Oberfläche kombinieren – und das vollständig selbst gehostet.
In diesem Artikel lernst du, wie du AFFiNE CE unter Debian installierst, konfigurierst und sicher betreibst – wahlweise mit Docker Compose oder nativ.
Was ist AFFiNE CE?
AFFiNE ist ein Open-Source-Projekt, das Dokumenten-, Datenbank- und Whiteboard-Funktionen in einem „All-in-One Workspace“ vereint. Die Community Edition (CE) ist die kostenlose, selbst hostbare Variante. Sie richtet sich an:
- Selbsthoster und Entwickler
- Teams mit Datenschutzanspruch
- Power-User, die Notion-ähnliche Tools lokal betreiben wollen
AFFiNE ist local-first, d. h. alle Daten bleiben zunächst lokal gespeichert und können optional über einen Server oder die AFFiNE Cloud synchronisiert werden.
Offizielle Seite: https://affine.pro GitHub Repository: https://github.com/toeverything/AFFiNE
Systemvoraussetzungen
| Komponente | Empfohlen | | ------------------------------------ | -------------------------- | | Betriebssystem | Debian 12 oder 13 (64-Bit) | | CPU | x86_64 (Intel oder AMD) | | RAM | mind. 2 GB | | Speicherplatz | mind. 5 GB frei | | Docker (optional) | Version ≥ 24 | | Node.js (bei manueller Installation) | Version 18+ | | Git | Version 2.3+ |
Variante 1: Installation mit Docker Compose
Diese Methode ist die einfachste und wird von den Entwicklern empfohlen.
Schritt 1: Docker & Docker Compose installieren
``bash sudo apt update && sudo apt upgrade -y sudo apt install ca-certificates curl gnupg lsb-release -y ``
Füge das Docker-Repository hinzu:
``bash sudo mkdir -p /etc/apt/keyrings curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg echo \ "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \ https://download.docker.com/linux/debian $(lsb_release -cs) stable" | \ sudo tee /etc/apt/sources.list.d/docker.list > /dev/null ``
Installiere Docker + Compose:
``bash sudo apt update sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin -y ``
Überprüfe:
``bash docker --version docker compose version ``
Schritt 2: Projektverzeichnis anlegen
``bash mkdir -p /opt/affine-ce cd /opt/affine-ce ``
Schritt 3: Docker-Compose-Datei erstellen
Erstelle die Datei docker-compose.yml:
``bash sudo nano docker-compose.yml ``
Füge folgendes Setup ein:
``yaml version: '3.9' services: affine: image: ghcr.io/toeverything/affine-self-hosted:latest container_name: affine restart: unless-stopped ports: - "3010:3010" volumes: - ./data:/root/.affine environment: - AFFINE_SERVER_HOST=0.0.0.0 - AFFINE_SERVER_PORT=3010 - AFFINE_MODE=production ``
Hinweis: AFFiNE läuft im Container auf Port 3010. Du kannst diesen Port bei Bedarf anpassen (z. B. 8080:3010).
Schritt 4: Container starten
``bash sudo docker compose up -d ``
Überprüfe den Status:
``bash sudo docker ps ``
Schritt 5: Zugriff über Browser
Nach dem Start erreichst du AFFiNE über:
`` http://``
Beispiel:
`` http://192.168.1.100:3010 ``
Beim ersten Aufruf erscheint die Weboberfläche mit Optionen zum Erstellen neuer Projekte und Notizräume.
Schritt 6: Daten sichern & aktualisieren
AFFiNE speichert Daten im Volume ./data. Sichere dieses Verzeichnis regelmäßig:
``bash tar czf affine-backup-$(date +%F).tar.gz data/ ``
Um ein Update durchzuführen:
``bash sudo docker compose pull sudo docker compose down sudo docker compose up -d ``
Variante 2: Manuelle Installation auf Debian (ohne Docker)
Diese Methode richtet sich an Entwickler oder Nutzer, die AFFiNE nativ kompilieren möchten.
Schritt 1: Abhängigkeiten installieren
``bash sudo apt update && sudo apt install git curl nodejs npm -y ``
Überprüfe Versionen:
``bash node -v npm -v ``
Schritt 2: Repository klonen
``bash cd /opt sudo git clone https://github.com/toeverything/AFFiNE.git cd AFFiNE ``
Schritt 3: Abhängigkeiten installieren
``bash npm install ``
Falls du pnpm bevorzugst (schneller und stabiler):
``bash sudo npm install -g pnpm pnpm install ``
Schritt 4: Server starten
Starte den Entwicklungsserver:
``bash npm run dev ``
Oder für Produktivbetrieb:
``bash npm run start ``
AFFiNE läuft standardmäßig auf Port 3010.
Zugriff:
`` http://localhost:3010 ``
Schritt 5: Systemdienst anlegen (optional)
Damit AFFiNE automatisch startet:
``bash sudo nano /etc/systemd/system/affine.service ``
Inhalt:
```ini [Unit] Description=AFFiNE CE Selfhosted After=network.target
[Service] Type=simple User=www-data WorkingDirectory=/opt/AFFiNE ExecStart=/usr/bin/npm run start Restart=always
[Install] WantedBy=multi-user.target ```
Aktivieren und starten:
``bash sudo systemctl enable affine sudo systemctl start affine ``
Sicherheit & Tipps
1. Reverse Proxy mit HTTPS (z. B. Nginx)
Erstelle eine Nginx-Konfiguration für SSL:
``bash sudo apt install nginx certbot python3-certbot-nginx -y ``
Beispiel-Konfiguration /etc/nginx/sites-available/affine:
```nginx server { listen 80; server_name affine.meinedomain.de; return 301 https://$host$request_uri; }
server { listen 443 ssl; server_name affine.meinedomain.de;
ssl_certificate /etc/letsencrypt/live/affine.meinedomain.de/fullchain.pem; ssl_certificate_key /etc/letsencrypt/live/affine.meinedomain.de/privkey.pem;
location / { proxy_pass http://127.0.0.1:3010; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; } } ```
Aktiviere das Setup:
``bash sudo ln -s /etc/nginx/sites-available/affine /etc/nginx/sites-enabled/ sudo systemctl reload nginx sudo certbot --nginx -d affine.meinedomain.de ``
2. Zugriff einschränken
Falls AFFiNE nur intern genutzt werden soll, kannst du den Port 3010 über die Firewall sperren:
``bash sudo ufw allow 80,443/tcp sudo ufw deny 3010/tcp sudo ufw enable ``
3. Backups automatisieren
Lege einen täglichen Cronjob für Container-Backups an:
``bash crontab -e ``
Beispiel:
`` 0 3 * cd /opt/affine-ce && tar czf /opt/backups/affine-$(date +\%F).tar.gz data/ ``
Die AFFiNE Community Edition bietet eine beeindruckende Kombination aus Textverarbeitung, Datenbanken und visueller Planung – vollständig Open Source und selbst hostbar.
Mit Docker ist die Installation in wenigen Minuten erledigt, und dank des local-first-Prinzips behältst du volle Kontrolle über deine Daten. Für produktive Umgebungen empfiehlt sich ein Reverse Proxy mit HTTPS und regelmäßige Backups.
Besonders praktisch: AFFiNE läuft stabil auf kleinen VPS-Servern oder auch im Heimnetzwerk (z. B. auf einem Raspberry Pi 4 mit 4 GB RAM).
Nützliche Links
- Offizielle Seite: https://affine.pro
- GitHub Repository: https://github.com/toeverything/AFFiNE
- Dokumentation: https://docs.affine.pro
- Community & Diskussion: https://community.affine.pro
