Obsidian Sync & Publish selbst hosten

Obsidian ist ein leistungsstarkes Notizwerkzeug auf Markdown-Basis und findet vor allem in der Tech-Community großen Anklang. Durch die Möglichkeit, Dateien direkt auf der Festplatte zu speichern und Notizen mithilfe von Backlinks und Graphen zu verbinden, eignet es sich perfekt für das Organisieren komplexer Informationen und das Erstellen eines „zweiten Gehirns“. In dieser Anleitung zeige ich euch, wie ihr die beiden kostenpflichtigen Plugins Sync und Publish kostenlos selbst bereitstellen könnt.

Obsidian ist zwar leider nicht Open Source, hat aber dennoch eine extrem aktive Community, die viele Open-Source-Plugins entwickelt. Diese große Auswahl an Erweiterungen bietet flexible Anpassungsoptionen und ermöglicht es Nutzern, Obsidian optimal in ihren persönlichen Workflow zu integrieren.

Obsidian Sync – Notizen sicher synchronisieren

Obsidian Sync ist der offizielle Synchronisierungsdienst von Obsidian, mit dem Notizen auf verschiedenen Geräten (z. B. Desktop und mobile Geräte) verschlüsselt und sicher synchronisiert werden können. Für User ist das eine einfache Möglichkeit, ihre Notizen stets aktuell zu halten und von überall aus zu bearbeiten, ohne auf externe Cloud-Dienste angewiesen zu sein.

Kostenpunkt: ab 4 € pro Monat.

Obsidian Publish – Inhalte online veröffentlichen

Mit Obsidian Publish bietet Obsidian eine optionale Funktion, mit der Benutzer ihre Notizen und Wissenssammlungen als öffentliche Websites veröffentlichen können. Das eignet sich besonders für Tech-Blogger und Entwickler, die ihre Dokumentationen oder Wissensdatenbanken teilen wollen. Die Lösung ermöglicht ein anpassbares und zugängliches Layout, das ohne zusätzliche Webentwicklungskenntnisse auskommt.

Kostenpunkt: ab 8 € pro Monat.

Selbstgehosteter Obsidian Sync mit Seafile

Statt auf den offiziellen Obsidian Sync zu setzen, kannst du mithilfe von Seafile deine Notizen selbst hosten und synchronisieren. Seafile ist ein Open-Source-Cloudspeicher, der einfach auf einem eigenen Server betrieben werden kann. Durch das Seafile-Obsidian-Plugin kannst du die Markdown-Dateien aus deinem Obsidian-Vault direkt synchronisieren und zwischen verschiedenen Betriebssystemen teilen – ob Linux, Windows, Android oder iOS. Dieser Ansatz ermöglicht dir nicht nur die volle Kontrolle über deine Daten, sondern auch die Flexibilität, Notizen plattformübergreifend zu aktualisieren.

Selbstgehosteter Obsidian Publish mit Perlite

Für die Veröffentlichung deiner Notizen als statische Website ohne den Obsidian Publish-Dienst kannst du auf Perlite zurückgreifen. Perlite ist ein Open-Source-Tool, das Markdown-Dateien aus Obsidian zu einer statischen, durchsuchbaren Website verarbeitet.

Mit Docker kannst du Perlite einfach als Container laufen lassen und deine Notizen in einer ansprechenden Website öffentlich für Nutzer zugänglich machen

Inhaltsverzeichnis

1. Grundvoraussetzung

Docker & Docker Compose v2 (Debian / Ubuntu)
Traefik V3 Installation, Konfiguration und CrowdSec-Security
Seafile Server

2. Vorbereitung von Seafile

Für die selbstgehostete Synchronisierung von Obsidian betreibe ich einen Seafile-Server auf demselben Host, auf dem ich dieses Setup einrichte. Nach der Installation von Seafile könnt ihr in der Seafile-Oberfläche eine neue Bibliothek mit dem Namen obsidian-vault anlegen. Damit sich Obsidian automatisch mit dieser Bibliothek synchronisiert, verwendet das Seafile-Obsidian-Plugin.

Installiert das Plugin aus dem GitHub-Repository: Seafile Plugin für Obsidian.
Hinterlegt im Plugin die Zugangsdaten für euren Seafile-Server.
Nun wird euer Obsidian Vault automatisch synchronisiert!

Mit dieser Konfiguration bleibt euer Vault jederzeit plattformübergreifend und sicher zugänglich – ideal für die Arbeit auf verschiedenen Geräten und Betriebssystemen.

3. Perlite Installation per Docker

Um die Obsidian-Notizen als statische Website zu veröffentlichen, verwende ich Perlite in einem Docker-Container, der ebenfalls auf demselben lokalen Host wie der Seafile-Server läuft. Mit dieser Konfiguration könnt ihr eine durchsuchbare und einfach zugängliche Website für eure Obsidian-Notizen erstellen.

3.1 Ordnerstruktur anlegen

mkdir /opt/containers/perlite/web/config
touch /opt/containers/perlite/web/config/perlite.conf

3.2 Compose Datei anlegen

nano /opt/containers/perlite/compose.yml

services:
  perlite:
    image: sec77/perlite:latest
    container_name: perlite
    restart: unless-stopped
    environment:
      - NOTES_PATH=Obsidian
      - HIDE_FOLDERS=docs,private,trash
      - LINE_BREAKS=true
      - ABSOLUTE_PATHS=false
      - ALLOWED_FILE_LINK_TYPES=pdf,mp4
      - DISABLE_POP_HOVER=false
      - SHOW_TOC=true
      - SHOW_LOCAL_GRAPH=true
      - HOME_FILE=README
      - FONT_SIZE=15
      - HTML_SAFE_MODE=true
      - TEMP_PATH=/tmp
      - SITE_TITLE=Demo
      - SITE_TYPE=article
      - SITE_URL=
      - SITE_IMAGE=
      - SITE_DESC=
      - SITE_NAME=Perlite
      - SITE_TWITTER=https://x.com/
      - SITE_LOGO=perlite.svg
      - SITE_HOMEPAGE=https://perlite.secure77.de/
      - SITE_GITHUB=https://github.com/
    volumes:
      - ./perlite/Demo:/var/www/perlite/Demo:ro
    networks:
      - perlite

  web:
    image: nginx:stable
    container_name: perlite_web
    restart: unless-stopped
    volumes:
      - ./web/config/perlite.conf:/etc/nginx/conf.d/default.conf:ro
    volumes_from: 
      - perlite       
    depends_on:
      - perlite
    networks:
      - proxy
      - perlite
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.perlite.entrypoints=websecure"
      - "traefik.http.routers.perlite.rule=(Host(`perlite.server.de`))"
      - "traefik.http.routers.perlite.tls=true"
      - "traefik.http.routers.perlite.tls.certresolver=http_resolver"
      - "traefik.http.routers.perlite.service=perlite"
      - "traefik.http.services.perlite.loadbalancer.server.port=80"
      - "traefik.docker.network=proxy"
      - "traefik.http.routers.perlite.middlewares=default@file"
networks:
  proxy:
    external: true
  perlite:

Bitte anpassen:

Host(perlite.server.de)

3.3 nginx config anpassen

nano /opt/containers/perlite/web/config/perlite.conf

server {
    listen 80;
    server_name localhost;

    root /var/www/perlite;
    index index.php index.html index.htm;

    access_log /var/log/nginx/php-access.log;
    error_log /var/log/nginx/php-error.log;


    # PHP-FPM Configuration Nginx
    location ~ \.php$ {
        try_files $uri = 404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass perlite:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param REQUEST_URI $request_uri;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
    }

        location ~ /\.ht {
            deny all;
    }

    location ~* ^/(.*)/.obsidian/appearance.json$ {
        allow all;
    }

    location ~* ^/(.*)/.obsidian/(.*)/theme.css$ {
        allow all;
    }

    location ~ \.(git|github|obsidian|trash) {
        deny all;
    }

    location ~ \.(md|json)$ {
        deny all;
    }


}

3.4 Perlite und Obsidian richtig konfigurieren

Um Obsidian und Perlite korrekt zu konfigurieren, empfehle ich euch, den Guide des Entwicklers anzusehen. Dort findet ihr detaillierte Anweisungen zur richtigen Pfadeinstellung. Da der Guide die Schritte klar erklärt, verzichte ich hier auf zusätzliche Erläuterungen.

4. Seafile CLI-Client für den Server

Um Perlite Zugriff auf die synchronisierten Markdown-Dateien in Seafile zu ermöglichen, benötigen wir einen zusätzlichen Schritt. Da Seafile die Daten nicht im Klartext speichert, sondern in Chunks aufteilt, müssen wir ein Tool nutzen, das den Zugriff darauf ermöglicht.

Das Kommandozeilen-Tool seaf-cli bietet eine einfache Möglichkeit, um auf die in Seafile gespeicherten Daten zuzugreifen.

# Aktuelles AppImage laden

wget https://s3.eu-central-1.amazonaws.com/download.seadrive.org/Seafile-cli-x86_64-9.0.8.AppImage

# Ausführbar machen

chmod +x Seafile-cli-x86_64-9.0.8.AppImage

# Umbenennen

mv Seafile-cli-x86_64-9.0.8.AppImage seaf-cli

# In den richtigen Ordner kopieren

sudo cp seaf-cli /usr/local/bin

Die Seafile-x86_64.AppImage erfordert FUSE Version 2, um ausgeführt zu werden. Falls FUSE auf deinem System nicht installiert ist, findest du unter diesem Link eine Installationsanleitung. Tipp am Rande: Auf einem Proxmox-LXC-Container läuft FUSE2 nicht.

4.1 Grundlegende Verwendung

Den Client initialisieren und starten

# Wähle einen Ordner, um die Einstellungen des Seafile-Clients zu speichern, z. B. ~/seafile-client

mkdir ~/seafile-client            # Erstelle den Ordner für die Einstellungen

seaf-cli init -d ~/seafile-client  # Initialisiere den Seafile-Client mit diesem Ordner

seaf-cli start                     # Starte den Seafile-Client

4.2 Bibliothek herunterladen und synchronisieren

Um eine Bibliothek von einem Server herunterzuladen und zu synchronisieren, gehe wie folgt vor:

Bibliotheks-ID abrufen: Navigiere zur Bibliothek auf dem Server und finde die ID in der URL (z. B. f4962ce9-ba07-47b8-a83a-73dd96c2ebfd). Die ID könnt ihr zB. im Browser aus der Adressleiste kopieren -> https://cloud.seafile.ccom/library/b11c66e8-377d-4b03-85ec-5deeb1ef5045/Data/
Bibliothek herunterladen:

# syntax

seaf-cli download -l "Bibliotheks-ID" -s "Server-URL:Port" -d "Zielordner" -u "Benutzername" [-p "Passwort"]

Beispiel:

# syntax beispiel

seaf-cli download -l fbeb7e4f-fadd-4557-b919-5c34944b4ccd -s http://100.64.0.1:1234 -d /tmp -u freeplant@test.com

Dieser Befehl erstellt einen neuen Ordner mit dem Namen der Bibliothek im angegebenen Zielordner. Am einfachsten ist es wohl wenn Seafile und Perlite auf dem selben Host laufen.
Ihr werdet jetzt aufgefordert euer Passwort einzugeben. Danach sollte im Terminal stehen:

Starting to download ...

Library fbeb2e4f-f1dd-4357-b219-5133914baccd will be downloaded to /tmp

Der lokale Ordner wird mit der Bibliothek abgeglichen, wobei bestehende Dateien im Ordner mit denen in der Bibliothek zusammengeführt werden. Nach Ausführen des download oder sync Befehls wird der lokale Ordner automatisch mit der Bibliothek synchronisiert.

5. Perlite und Seafile verknüpfen

Jetzt haben wir den Sync zwischen Obsidian Vault und Seafile eingerichtet und zudem per seaf-cli direkten Zugriff auf die synchronisierten Daten vom Server aus. Damit können wir Perlite so konfigurieren, dass ausgewählte Notizen direkt über den Browser zugänglich gemacht werden.

Im nächsten Schritt passen wir die docker-compose.yaml-Datei von Perlite an, sodass Perlite auf den Ordner mit den synchronisierten Markdown-Dateien zugreift. In diesem Beispiel liegt der Obsidian Vault unter /tmp/obsidian-vault.

Hier die angepasste Konfigurationsdatei:

# docker-compose.yaml (perlite)
[...] # Wir mounten das Verzeichnis wo unser Obsidian Vault liegt
volumes:
  - /tmp/obsidian-vault/:/var/www/perlite/Obsidian:ro

[...] 
  - NOTES_PATH=Obsidian # Name des vaults im Container (rechte Seite des Volume Mappings)
  - HIDE_FOLDERS =docs,private # Ordner die ausgeblendet werden sollen

Hinweis
Denke daran, dass /tmp/obsidian-vault mit dem Pfad übereinstimmen muss, den du für die Synchronisierung deiner Obsidian-Notizen mit Seafile eingerichtet hast.

Mit diesen Schritten ist euer Setup mehr oder weniger vollständig, und Perlite stellt die Inhalte aus eurem Obsidian Vault im Browser korrekt dar.

Dein Browser sollte nun deinsynchronisiertes Vault anzeigen.

Der Sync über Seafile ist recht schnell, nach dem Speichern im lokalen Vault dauert es ca. 10 Sekunden, dann ist es auch online verfügbar.

Alle weiteren Variablen sind optional und selbsterklärend.

Quellen:

https://github.com/secure-77/Perlite

https://github.com/conql/obsidian-seafile

https://help.seafile.com/syncing_client/linux-cli

Autor

2TAP2B

Mit der Veröffentlichung von Ubuntu 10.04 bin ich zum ersten Mal in die Linux-Welt eingetaucht und seitdem ist es nicht nur ein treuer Begleiter, sondern auch eines meiner größten Hobbys. Seit einigen Jahren betreibe ich einen Homeserver. Beruflich stelle ich mich Herausforderungen im Hardwarebereich und repariere Großformatdrucker.
Alle Beiträge ansehen