Published on

Obsidian Sync und Publish Selfhosted

Authors
  • avatar
    Name
    Tobias Steltner
    Twitter

Intro

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

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

  • Installation: Richte zunächst einen Seafile-Server ein – entweder auf einem Linux-Server oder als Docker-Container.
  • Konfiguration des Plugins: Im Seafile-Obsidian-Plugin kannst du den Server so einrichten, dass es direkt auf den Vault zugreift und Dateien synchronisiert. So bleiben deine Notizen überall auf dem neuesten Stand.

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 oder nur für bestimmte Nutzer zugänglich machen:

  • Docker-Setup: Starte einen Docker-Container für Perlite und verlinke ihn mit deinem Vault-Verzeichnis.
  • Zugänglichkeit und Freigabe: Die Perlite-Website kann so konfiguriert werden, dass nur ausgewählte Inhalte online erscheinen – ideal für das Teilen von spezifischen Notizen oder Dokumentationen mit einem breiteren Publikum.

Installation Seafile per Docker

Für die selbstgehostete Obsidian-Synchronisierung betreibe ich einen Seafile-Server lokal zu Hause in einem Docker-Container. Mithilfe eines Reverse Proxy wird der Server durch ein SSL/TLS-Zertifikat abgesichert und ist unter einer eigenen Domain erreichbar. So können die Notizen sicher und verschlüsselt synchronisiert werden.

Hier ist ein Beispiel für meine docker-compose.yaml, die ihr als Vorlage für eure eigene Installation verwenden könnt:

docker-compose.yaml
services:
  db:
    image: mariadb:10.11
    container_name: seafile-mysql
    environment:
      - MYSQL_ROOT_PASSWORD=db_dev  # Required, set the root's password of MySQL service.
      - MYSQL_LOG_CONSOLE=true
      - MARIADB_AUTO_UPGRADE=1
    volumes:
      - /opt/seafile-mysql/db:/var/lib/mysql  # Required, specifies the path to MySQL data persistent store.
    networks:
      - seafile-net

  memcached:
    image: memcached:1.6.18
    container_name: seafile-memcached
    entrypoint: memcached -m 256
    networks:
      - seafile-net
          
  seafile:
    image: seafileltd/seafile-mc:11.0-latest
    container_name: seafile
    ports:
      - "80:80"
#     - "443:443"  # If https is enabled, cancel the comment.
    volumes:
      - /opt/seafile-data:/shared   # Required, specifies the path to Seafile data persistent store.
    environment:
      - DB_HOST=db
      - DB_ROOT_PASSWD=db_dev  # Required, the value should be root's password of MySQL service.
      - TIME_ZONE=Etc/UTC  # Optional, default is UTC. Should be uncomment and set to your local time zone.
      - SEAFILE_ADMIN_EMAIL=me@example.com # Specifies Seafile admin user, default is 'me@example.com'.
      - SEAFILE_ADMIN_PASSWORD=asecret     # Specifies Seafile admin password, default is 'asecret'.
      - SEAFILE_SERVER_LETSENCRYPT=false   # Whether to use https or not.
      - SEAFILE_SERVER_HOSTNAME=docs.seafile.com # Specifies your host name if https is enabled.
    depends_on:
      - db
      - memcached
    networks:
      - seafile-net

networks:
  seafile-net:

Wichtig: Vergesst nicht, eure persönlichen Daten wie Passwörter, E-Mail, Zeitzone etc. in der Konfigurationsdatei anzupassen, bevor ihr den Container startet.

Einrichtung der Obsidian-Bibliothek und Installation des Plugins

Nach der Seafile-Installation könnt ihr in der Seafile-Oberfläche eine neue Bibliothek mit dem Namen Obsidian Sync anlegen. Damit sich Obsidian automatisch mit dieser Bibliothek synchronisieren kann, nutzt das Seafile-Obsidian-Plugin:

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

Mit dieser Konfiguration ist euer Obsidian-Vault jederzeit plattformübergreifend und sicher zugänglich, ideal für die Arbeit auf mehreren Geräten und Betriebssystemen.

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.

Hier ist ein Beispiel, wie eure docker-compose.yaml-Datei für Perlite aussehen könnte:

docker-compose.yaml
services:
  perlite:
    image: sec77/perlite:latest
    container_name: perlite
    restart: unless-stopped
    environment:
      - NOTES_PATH=Demo
      - 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

  web:
    image: nginx:stable
    container_name: perlite_web
    restart: unless-stopped
    ports:
      - 80:80
    volumes:
      - ./web/config/perlite.conf:/etc/nginx/conf.d/default.conf:ro
    volumes_from: 
      - perlite       
    depends_on:
      - perlite

Wichtig um Obsidian und Perlite richtig zu konfigurieren schaut euch bitte den Guide vom Entwickler hier an.

Zudem benötigt ihr die nginx-Konfiguration für den Webserver. Diese könnte wie folgt aussehen:

nginx.config
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;

    }

  

}

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.

seaf-cli-install
# 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.

Grundlegende Verwendung

Den Client initialisieren und starten

basic-commands
# 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

Bibliothek herunterladen und synchronisieren

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

  1. 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/
  2. Bibliothek herunterladen:
download
seaf-cli download -l "Bibliotheks-ID" -s "Server-URL:Port" -d "Zielordner" -u "Benutzername" [-p "Passwort"]

Beispiel:

download-example
seaf-cli download -l 0536c006-8a43-449e-8718-39f12111620d -s http://cloud.seafile.com -d /tmp -u freeplant@test.com

Dieser Befehl erstellt einen neuen Ordner mit dem Namen der Bibliothek im angegebenen Zielordner.

NOTE

Hinweis Hinweis: Wenn das Passwort nicht direkt angegeben wird -p "Passwort", wird es später abgefragt, was sicherer ist.

Bibliothek mit einem bestehenden Ordner synchronisieren:

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

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.

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.

Beispiel docker-compose.yaml für Perlite

Hier die angepasste Konfigurationsdatei:

docker-compose.yaml
# 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 es vaults im Container (rechte Seite des Volume Mappings)
      - HIDE_FOLDERS =docs,private # Ordner die ausgeblendet werden sollen

WARNING

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.

Alle weiteren Variablen sind optional und selbsterklärend.

View on GitHub