Doory: Kostenlose Canva Alternative selbst hosten mit Docker

Canva ist praktisch, keine Frage. Aber jedes Bild, jede Vorlage und jedes Logo liegt auf fremden Servern, und die besseren Funktionen kosten jeden Monat Geld. Mit Doory gibt es jetzt eine kostenlose Canva-Alternative, die du komplett selbst hosten kannst: im Browser, mit Vorlagen, Icons, Animationen und Echtzeit-Zusammenarbeit.

Ich habe Doory auf einem CasaOS-Server über Portainer installiert und auf meinem ZimaOS-Homeserver direkt über den App-Import. Dabei bin ich über ein paar Stolperfallen gefallen, die in der offiziellen Anleitung nicht stehen. In diesem Artikel zeige ich dir den Weg, der bei mir am Ende sauber funktioniert hat.

tl;dr Doory ist eine kostenlose Open-Source-Alternative zu Canva, die du per Docker auf deinem eigenen Server betreibst. Die Bedienung lehnt sich stark an Canva an, du musst also nichts neu lernen. Seit Version 0.2.0 gibt es fertige Images, selbst bauen ist nicht mehr nötig. Mit dem YAML-Generator erstellst du deine docker-compose.yml in einer Minute und installierst sie entweder als Stack in Portainer oder per App-Import in ZimaOS oder CasaOS. Der erste Start dauert einige Minuten, danach legst du über „Sign up“ dein Konto an. Grenzen: Beim Freistellen komplexer Bilder kommt Doory nicht an Canva Pro heran, und Videoclips sind im offiziellen Image noch abgeschaltet.

Was ist Doory?

Doory ist ein Open-Source-Design-Editor, der im Browser läuft. Entwickelt wird er von Siam (github.com/shaongitbd/doory). Du gestaltest damit Social-Media-Posts, Stories, Poster, Präsentationen, Einladungen, Lebensläufe, YouTube-Thumbnails oder Visitenkarten. Entweder startest du mit einer Vorlage oder mit einer leeren Seite.

Was mich beim ersten Ausprobieren überrascht hat: Der Editor fühlt sich nicht wie ein Hobbyprojekt an. Doory ist eine ernstzunehmende App, und der Workflow ist dem von Canva so ähnlich, dass ich mich ohne Einarbeitung zurechtgefunden habe.

Die wichtigsten Funktionen im Überblick:

Ehrliche Einordnung

Doory ist ein junges Projekt. Der Editor ist vollständig, die Vorlagen-Bibliothek dagegen noch klein: Es gibt zehn Starter-Vorlagen. Wer die riesige Vorlagen-Auswahl von Canva gewohnt ist, wird hier also erst mal selbst gestalten müssen.

Hintergrund entfernen: Doory gegen Canva Pro

Das Freistellen läuft bei Doory direkt in deinem Browser, ein externer KI-Dienst ist dabei nicht beteiligt. Bei einfachen Motiven funktioniert das für eine kostenlose App erstaunlich gut. Bei komplexen Bildern sieht es anders aus. Ich habe dasselbe Produktfoto in beiden Programmen freigestellt, einen USB-Adapter in der Hand vor einem Auto-Cockpit:

Doory lässt rund um Finger und Adapter helle Säume und Reste des Hintergrunds stehen:

Canva Pro schneidet dasselbe Bild sauber aus, auch zwischen den Fingern:

Im Vergleich zu Canva Pro ist das Ergebnis von Doory hier Mumpitz. Wer wie ich regelmäßig Produktfotos freistellt, ist mit Doory zumindest bei solchen Motiven aufgeschmissen. Doory kann zwar ein stärkeres Freistell-Modell auf einem eigenen KI-Server ansprechen, das habe ich aber nicht ausprobiert.

Ganz anders sieht es bei Porträts aus. Ein Foto von mir hat Doory ordentlich freigestellt, inklusive Haaransatz und Schultern. Menschen erkennt der Freisteller offenbar deutlich besser als ein Produkt in der Hand vor unruhigem Hintergrund. Für Profilbilder, Team-Fotos oder Thumbnails reicht Doory also durchaus.

Wo die Grenze liegt, zeigt ein drittes Beispiel: eine Wackelkopf-Figur in einer Strandbar, daneben ein Server-Schrank voller Spinnweben.

Bar und Server-Schrank entfernt Doory zwar, verliert dabei aber die halbe Figur. Die Beine verblassen, von den Schuhen bleibt nur ein Schatten, und an den Haaren franst der Rand aus:

Canva Pro stellt die Figur komplett frei, mit Sprungfeder, Hose und Schuhen:

Obwohl die Figur einem Menschen ähnelt, scheitert Doory hier. Der Freisteller kommt offenbar vor allem mit echten Personen gut zurecht, bei allem anderen ist das Ergebnis Glückssache.

Bild lässt sich nicht einfügen? Mehrbild-JPEGs exportieren

Beim Testen meldete Doory bei einem Foto nur „That image could not be added.“ Den Grund verrät das Log von doory-api: Das Bild war ein JPEG im Format MPO (Multi-Picture Object). In so einer Datei stecken mehrere Bilder, das ist typisch für manche iPhone- und Kamerafotos, zum Beispiel mit Tiefeninformationen. Doory 0.2.0 kennt dieses Format noch nicht und bricht den Upload ab.

Die Lösung ist einfach: Öffne das Foto auf dem Mac in der Vorschau, wähle Ablage > Exportieren und speichere es als JPEG. Mit jedem anderen Bildprogramm geht das genauso. Das exportierte Bild enthält nur noch ein Bild und lässt sich danach ganz normal einfügen.

Videoclips nur mit ffmpeg

Seit Version 0.2.0 kann Doory Videoclips in Designs einbauen. Dafür braucht das Backend das Programm ffmpeg. Das offizielle Image wird ohne ffmpeg gebaut, die Video-Funktion ist darin also abgeschaltet (VIDEO_ENABLED=false). Ich habe das in einem GitHub-Issue angesprochen. Bis sich daran etwas ändert, bekommst du Videos nur, wenn du die Images selbst aus dem Quellcode baust. Wie das geht, steht in der offiziellen Anleitung.

Fertige Docker-Images dank GitHub-Issue

Als ich Doory zum ersten Mal installiert habe, gab es noch keine fertigen Docker-Images. Ich musste sie auf meinem Server selbst aus dem Quellcode bauen. Das geht, ist aber gerade auf einem NAS oder mit Oberflächen wie ZimaOS, CasaOS oder Portainer umständlich.

Also habe ich die Entwickler am 18. Oktober 2026 in einem GitHub-Issue gefragt, ob sie fertige Images veröffentlichen können. Die Antwort kam schneller als gedacht: Einen Tag später waren die ersten offiziellen Images für Version 0.1.0 online, für normale PCs und Server (amd64) und für ARM-Geräte wie den Raspberry Pi (arm64). Seit dem 23. Oktober 2026 gibt es Version 0.2.0, und die Images erscheinen jetzt mit jeder neuen Version. Die Installation ist dadurch deutlich einfacher geworden, und genau diesen Weg zeige ich dir jetzt.

Doory oder Penpot?

Wenn du nach einer Open-Source-Alternative zu Canva suchst, landest du schnell bei Penpot. Beide laufen im Browser, beide kannst du selbst hosten. Trotzdem sind es zwei völlig verschiedene Werkzeuge.

Doory ahmt Canva nach. Die Leiste links mit Vorlagen, Text, Elementen und Uploads, die Werkzeugleiste über der Seite, der Teilen-Knopf oben rechts: Alles sitzt dort, wo du es von Canva kennst. Selbst die Abläufe sind gleich. Du wählst eine Vorlage, tauschst Text und Bilder aus und lädst das Ergebnis herunter. Wer mit Canva arbeitet, muss also nichts neu lernen.

Penpot ist dagegen komplett anders. Es ist eine Alternative zu Figma und richtet sich an Leute, die Oberflächen für Websites und Apps entwerfen. Du arbeitest mit Boards und Komponenten, baust Layouts, die sich wie CSS verhalten, und klickst daraus Prototypen zusammen. Entwickler holen sich am Ende den passenden Code direkt aus dem Entwurf. Das ist mächtig, folgt aber einem ganz eigenen Konzept. Wer aus Canva kommt, fängt bei Penpot praktisch von vorn an.

Meine Faustregel: Willst du etwas veröffentlichen, das gut aussieht, nimm Doory. Willst du etwas entwerfen, das später programmiert wird, nimm Penpot.

Was du für Doory brauchst

• Einen Server mit Docker, zum Beispiel ZimaOS, CasaOS, Unraid, Synology oder einen Linux-Rechner
• Portainer oder ZimaOS bzw. CasaOS mit dem eingebauten App-Import, alternativ die Kommandozeile
• Etwa 2 GB freien Arbeitsspeicher, dazu einige GB Speicherplatz
• Etwas Geduld beim ersten Start, weil Doory dann Icons, Schriften und Vorlagen herunterlädt

Doory besteht aus vier Containern: einer PostgreSQL-Datenbank, dem Backend (API), einem Echtzeit-Server für das gemeinsame Bearbeiten und einem Webserver, der die Oberfläche ausliefert.

Die offizielle Anleitung des Projekts arbeitet mit git clone und einer .env-Datei. Für Portainer, ZimaOS oder CasaOS ist das unpraktisch. Deshalb bekommst du hier eine YAML-Datei, in der alle Einstellungen direkt drinstehen.

Vorbereitung für beide Wege

Die YAML mit dem Generator erstellen

Am schnellsten kommst du mit meinem Generator zu deiner YAML. Trag die IP deines Servers ein, und wenn du magst, einen anderen Port oder Datenordner. Secret Key und Datenbank-Passwort erzeugt er gleich mit, und für Weg 2 hängt er auch den Block für das ZimaOS-Dashboard an.

Kopiere das Ergebnis und mach direkt mit Weg 1 über Portainer oder Weg 2 auf ZimaOS oder CasaOS weiter. Die folgenden Abschnitte brauchst du nur, wenn du die YAML lieber von Hand anpasst.

Den Haken bei Heimnetz-Sperre lässt du weg, außer du willst die Alpha-Funktion ausprobieren, die ich weiter unten beschreibe.

Wo Doory seine Daten speichert

Doory speichert seine Daten in diesen Ordnern. Anlegen musst du sie nicht, Docker erstellt sie beim ersten Start:

/DATA/AppData/doory/pgdata
/DATA/AppData/doory/media
/DATA/AppData/doory/exports

Wie bei Papra gibt es hier ein Rechteproblem: Doory läuft im Container nicht als root, sondern als Benutzer mit der ID 10001. Der darf in Ordner, die root gehören, nicht schreiben. Deshalb steht in der YAML ein kleiner Helfer-Container init-perms, der die Rechte einmal beim Start richtig setzt.

Passwort und Schlüssel erzeugen

Ohne Generator brauchst du zwei zufällige Werte: ein Datenbank-Passwort und einen geheimen Schlüssel für Django. Erzeuge sie im Terminal mit:

openssl rand -hex 16   # Datenbank-Passwort
openssl rand -hex 32   # Secret Key

Nimm für das Datenbank-Passwort nur Buchstaben und Zahlen. Es landet in einer URL, und Sonderzeichen würden dort Probleme machen.

Docker-Compose-YAML für Doory (ohne .env)

Diese YAML ist die Grundlage für beide Wege. Kopiere sie zuerst in einen Texteditor und passe sie dort an:

name: doory

x-doory-env: &doory-env
  DJANGO_SETTINGS_MODULE: doory.settings.prod
  # Eigenen Wert eintragen: openssl rand -hex 32
  DJANGO_SECRET_KEY: "HIER-DEIN-SECRET-KEY"
  # IP deines Servers und Port eintragen
  SITE_URL: &site "http://192.168.x.x:8585"
  CSRF_TRUSTED_ORIGINS: *site
  # IP deines Servers, mit Komma getrennt weitere Hostnamen
  DJANGO_ALLOWED_HOSTS: "192.168.x.x,localhost"
  # Gleiches Passwort wie unten bei POSTGRES_PASSWORD
  DATABASE_URL: "postgres://doory:HIER-DEIN-DB-PASSWORT@db:5432/doory"
  CACHE_URL: "dbcache://doory_cache"
  MEDIA_ROOT: /app/media
  EXPORT_STORAGE_ROOT: /app/exports
  REDIS_URL: ""
  # Plain HTTP im Heimnetz. Hinter einem HTTPS-Reverse-Proxy beide auf "true".
  SECURE_SSL_REDIRECT: "false"
  SECURE_COOKIES: "false"
  NUM_PROXIES: "1"
  # Inhalte beim ersten Start herunterladen (Icons, Fonts, Vorlagen, Freisteller-Modell, Audio)
  DOORY_SYNC_ELEMENTS: "true"
  DOORY_SYNC_FONTS: "true"
  DOORY_SEED_TEMPLATES: "true"
  DOORY_SYNC_MODELS: "true"
  DOORY_SYNC_AUDIO: "true"
  DOORY_ELEMENTS_BRAND_LOGOS: "false"
  DOORY_SIZE_PRESETS_MODE: extend
  # Speicherplatz pro Benutzer in Bytes (Standard wären 2 GB). 53687091200 = 50 GB
  USER_STORAGE_QUOTA_BYTES: "53687091200"
  # PDF-Export auf dem Server (Vektor-PDF). Das offizielle Image bringt Chromium dafür mit.
  SERVER_PDF_ENABLED: "true"
  EXPORT_RENDER_PAGE_URL: "http://doory-web:8080/render.html"

services:
  # Setzt einmalig die Rechte auf die Datenordner
  init-perms:
    image: alpine:3.20
    container_name: doory-init-perms
    restart: "no"
    command: ["sh", "-c", "chown -R 10001:10001 /media /exports"]
    volumes:
      - /DATA/AppData/doory/media:/media
      - /DATA/AppData/doory/exports:/exports

  db:
    image: postgres:16-alpine
    container_name: doory-db
    restart: unless-stopped
    environment:
      POSTGRES_DB: doory
      POSTGRES_USER: doory
      POSTGRES_PASSWORD: "HIER-DEIN-DB-PASSWORT"
    volumes:
      - /DATA/AppData/doory/pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U doory -d doory"]
      interval: 5s
      timeout: 5s
      retries: 12
    networks:
      - doory

  api:
    image: ghcr.io/shaongitbd/doory-backend:0.2.0
    container_name: doory-api
    restart: unless-stopped
    init: true
    depends_on:
      init-perms:
        condition: service_completed_successfully
      db:
        condition: service_healthy
    security_opt:
      - no-new-privileges:true
    environment: *doory-env
    volumes:
      - /DATA/AppData/doory/media:/app/media
      - /DATA/AppData/doory/exports:/app/exports
    healthcheck:
      test: ["CMD", "python", "/app/healthcheck.py"]
      interval: 15s
      timeout: 5s
      start_period: 600s
      retries: 5
    # Chromium (PDF-Export) braucht mehr Shared Memory als die 64 MB, die Docker sonst vergibt
    shm_size: "512m"
    networks:
      doory:
        aliases: [doory-api]

  realtime:
    image: ghcr.io/shaongitbd/doory-backend:0.2.0
    container_name: doory-realtime
    restart: unless-stopped
    init: true
    mem_limit: 2g
    depends_on:
      api:
        condition: service_healthy
    security_opt:
      - no-new-privileges:true
    environment:
      <<: *doory-env
      HEALTH_PORT: "8001"
      DOORY_SYNC_ELEMENTS: "false"
      DOORY_SYNC_FONTS: "false"
      DOORY_SEED_TEMPLATES: "false"
      DOORY_SYNC_MODELS: "false"
      DOORY_SYNC_AUDIO: "false"
    volumes:
      - /DATA/AppData/doory/media:/app/media
    command:
      - uvicorn
      - doory.asgi:application
      - --host
      - 0.0.0.0
      - --port
      - "8001"
      - --workers
      - "1"
      - --ws
      - auto
      - --ws-max-size
      - "2097152"
      - --lifespan
      - "off"
      - --no-server-header
      - --timeout-graceful-shutdown
      - "20"
    healthcheck:
      test: ["CMD", "python", "/app/healthcheck.py"]
      interval: 15s
      timeout: 5s
      start_period: 60s
      retries: 5
    networks:
      doory:
        aliases: [doory-realtime]

  web:
    image: ghcr.io/shaongitbd/doory-frontend:0.2.0
    container_name: doory-web
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    depends_on:
      api:
        condition: service_healthy
      realtime:
        condition: service_healthy
    ports:
      - "8585:8080"
    volumes:
      - /DATA/AppData/doory/media:/srv/media:ro
    networks:
      doory:
        aliases: [doory-web]

networks:
  doory:
    name: doory

Was du anpassen musst

• DJANGO_SECRET_KEY: dein zufälliger Schlüssel aus openssl rand -hex 32.
• HIER-DEIN-DB-PASSWORT: steht zweimal in der Datei, bei POSTGRES_PASSWORD und in der DATABASE_URL. Beide Werte müssen gleich sein.
• 192.168.x.x: die IP deines Servers, bei SITE_URL und bei DJANGO_ALLOWED_HOSTS.
• Port 8585: Willst du einen anderen Port, ändere ihn bei ports (nur die linke Zahl) und in der SITE_URL. Passen die beiden nicht zusammen, lehnt Doory Anmeldungen ab.
• /DATA/AppData/doory: falls deine Apps woanders liegen.
• 0.2.0: die Version von Doory. Sie steht dreimal in der Datei, bei api, realtime und web. Die neueste findest du auf der Paketseite von Doory.

Mit der fertigen YAML installierst du Doory entweder über Portainer oder direkt auf ZimaOS oder CasaOS. Du brauchst nur einen der beiden Wege.

Weg 1: Doory als Stack in Portainer installieren

Den Stack anlegen

• Gehe in Portainer auf Stacks und dann auf + Add stack.
• Nenne den Stack doory.
• Füge im Web-Editor deine angepasste YAML ein.
• Klicke auf Deploy the stack.

Erster Start in Portainer

Jetzt brauchst du etwas Geduld. Der Container doory-api lädt beim ersten Start rund 27.500 Icons, die Schriften, die Vorlagen und das Modell für das Freistellen herunter. In dieser Zeit zeigt Portainer ihn als „starting“ an. Die anderen Container warten, bis er fertig ist.

Am Ende sollte es so aussehen:

Vier Container stehen auf healthy, doory-init-perms auf exited – code 0. Das sieht nach einem Fehler aus, ist aber gewollt: Der Helfer hat seine Arbeit erledigt und sich beendet.

Rufe Doory jetzt im Browser auf:

http://DEINE-IP:8585

Konto anlegen und loslegen

Doory legt kein Standard-Login an, und du brauchst auch keins. Klicke auf der Startseite auf Sign up, gib E-Mail-Adresse und Passwort ein, fertig. Damit kannst du sofort loslegen. Genauso legen sich auch alle anderen ihr Konto an, mit denen du Doory teilst.

Ein Konto ist nicht einmal Pflicht: Ohne Anmeldung gestaltest du direkt als Gast. Deine Entwürfe liegen dann aber nur im Browser auf diesem Gerät. Löschst du die Browserdaten oder wechselst das Gerät, sind sie weg. Für alles, was du behalten willst, legst du deshalb besser ein Konto an. Beim Registrieren übernimmt Doory deine Gast-Entwürfe.

Optional: Admin-Konto in Portainer anlegen

Die meisten brauchen diesen Schritt nicht. Ein Admin-Konto ist nur nötig, wenn du die Verwaltung unter http://DEINE-IP:8585/admin/ nutzen willst, zum Beispiel um ein Konto zu sperren.

• Klicke in Portainer bei doory-api auf das Konsolen-Symbol >_ und dann auf Connect.
• Gib diesen Befehl ein und beantworte die Fragen nach E-Mail-Adresse und Passwort:

python manage.py createsuperuser

Tipp: Passwort vergessen? Mit python manage.py changepassword deine@email.de setzt du es in derselben Konsole neu.

Weg 2: Doory auf ZimaOS installieren (oder CasaOS)

Seit es fertige Images gibt, brauchst du für Doory kein Portainer mehr. ZimaOS und CasaOS können die YAML direkt importieren, so läuft Doory inzwischen auch bei mir daheim. Die App erscheint dann wie jede andere auf dem Dashboard.

Den Block für das Dashboard ergänzen

Hast du die YAML mit dem Generator für Weg 2 erstellt, ist dieser Block schon drin, und du kannst direkt importieren. Sonst hänge ans Ende deiner angepassten YAML diesen Block an. Er enthält Name, Beschreibung, Icon und Port für das Dashboard:

x-casaos:
  architectures:
    - amd64
    - arm64
  main: web
  author: shaongitbd
  developer: shaongitbd
  category: Productivity
  description:
    en_us: Open-source, self-hosted design editor (Canva alternative) with real-time co-editing.
    de_de: Open-Source Design-Editor zum Selbsthosten (Canva-Alternative) mit Echtzeit-Zusammenarbeit.
  # IP deines Servers eintragen
  icon: http://192.168.x.x:8585/icons/icon-192.png
  tagline:
    en_us: Self-hosted design editor
    de_de: Selbstgehosteter Design-Editor
  title:
    en_us: Doory
  index: /
  port_map: "8585"
  scheme: http

Die App importieren

• Klicke in ZimaOS auf dem Dashboard oben rechts auf das + und wähle Benutzerdefinierte App installieren.

• Klicke im folgenden Fenster oben auf Import und wähle Docker Compose.

• Füge die komplette YAML ein, bestätige und klicke auf Installieren.

In CasaOS findest du das Gleiche im App Store unter Custom Install, dort ebenfalls mit einem Import-Knopf.

Erster Start auf ZimaOS

Auch hier brauchst du Geduld. Der Container doory-api lädt beim ersten Start rund 27.500 Icons, die Schriften, die Vorlagen und das Modell für das Freistellen herunter, und die anderen Container warten auf ihn. Die Installation kann deshalb einige Minuten dauern. Danach öffnest du Doory über die Kachel auf dem Dashboard oder im Browser unter http://DEINE-IP:8585.

Konto anlegen und mit Doory loslegen

Doory legt kein Standard-Login an, und du brauchst auch keins. Klicke auf der Startseite auf Sign up, gib E-Mail-Adresse und Passwort ein, fertig. Damit kannst du sofort loslegen. Genauso legen sich auch alle anderen ihr Konto an, mit denen du Doory teilst.

Ein Konto ist nicht einmal Pflicht: Ohne Anmeldung gestaltest du direkt als Gast. Deine Entwürfe liegen dann aber nur im Browser auf diesem Gerät. Löschst du die Browserdaten oder wechselst das Gerät, sind sie weg. Für alles, was du behalten willst, legst du deshalb besser ein Konto an. Beim Registrieren übernimmt Doory deine Gast-Entwürfe.

Optional: Admin-Konto per SSH anlegen

Auch hier gilt: Die meisten brauchen das nicht. Ein Admin-Konto ist nur für die Verwaltung unter http://DEINE-IP:8585/admin/ nötig. Hast du Doory schon einmal installiert und die Ordner unter /DATA/AppData/doory/ behalten, ist dein altes Konto ohnehin noch da.

Willst du einen Admin, meldest du dich per SSH auf deinem Server an und gibst diesen Befehl ein:

docker exec -it doory-api python manage.py createsuperuser

Doory fragt dich nach E-Mail-Adresse und Passwort.

Tipp: Passwort vergessen? Mit docker exec -it doory-api python manage.py changepassword deine@email.de setzt du es neu.

Wie sicher ist so eine Installation?

Bevor ich Doory auf dem CasaOS-Server installiert habe, wollte ich wissen: Kann so ein junges Projekt mein Netzwerk gefährden? Ich habe mir dafür die Konfiguration und Teile des Quellcodes angesehen. Ein Sicherheitsaudit ersetzt das nicht, aber das Ergebnis hat mich beruhigt.

Was gut gelöst ist

• Kein root im Container: Das Backend läuft als Benutzer 10001, der Webserver ebenfalls ohne Root-Rechte. Dazu verhindert no-new-privileges, dass sich ein Prozess nachträglich mehr Rechte holt.
• Kein Zugriff auf Docker oder den Host: Kein Container bekommt den Docker-Socket, privileged oder das Host-Netzwerk. Ein gekaperter Container kann also nicht einfach andere Container oder den Server steuern.
• Nur ein offener Port: Von außen erreichbar ist nur der Webserver auf 8585. Datenbank und Backend hängen ausschließlich im internen Docker-Netz.
• Bild-URLs nur aus dem Internet: Wenn Doory Bilder von einer Adresse lädt, lässt der Code nur öffentliche Adressen über HTTPS zu. Damit ist der naheliegende Trick verbaut, über diese Funktion deinen Router oder dein NAS anzusprechen. Vom Heimnetz abgeschottet ist der Container dadurch aber nicht. Wer das will, findet weiter unten die Heimnetz-Sperre (Alpha).
• Schutz vor Passwort-Raten: Nach zu vielen Fehlversuchen wird ein Konto vorübergehend gesperrt.

Der Helfer init-perms läuft zwar als root, setzt aber nur einmal die Rechte auf zwei Ordner und beendet sich dann.

Wo du selbst aufpassen musst

Die Version, die du installierst. Doory ist ein junges Projekt mit einem kleinen Team. Pinne deshalb eine feste Version wie 0.2.0 statt latest. Dann ändert sich auf deinem Server nichts, bis du selbst eine neue Versionsnummer einträgst.

Jeder kann sich registrieren. Die Registrierung lässt sich in Doory nicht abschalten. Wer die Adresse kennt und dein Netz erreicht, kann sich ein Konto anlegen und Speicherplatz belegen. Im Heimnetz oder in einem kleinen Team ist das kein Problem. Stell Doory aber auf keinen Fall per Portfreigabe ins Internet. Und überleg dir, ob du das Kontingent pro Benutzer wirklich so hoch setzen willst wie ich.

Keine Verschlüsselung. Die Anleitung nutzt einfaches HTTP. Im eigenen Netz ist das vertretbar, Passwörter gehen aber im Klartext über die Leitung. Brauchst du Zugriff von unterwegs, nimm ein VPN wie Tailscale oder einen Reverse Proxy mit HTTPS. Dann stellst du SECURE_SSL_REDIRECT und SECURE_COOKIES auf "true" und trägst bei SITE_URL die https://-Adresse ein.

Chromium. Ein Browser auf dem Server ist die größte Angriffsfläche im Stack. Im offiziellen Image ist er immer dabei. Er wird zwar nur gestartet, wenn jemand ein PDF exportiert, aber wer ganz darauf verzichten will, muss die Images selbst ohne Chromium bauen (siehe offizielle Anleitung). Dann gibt es den PDF-Export nur noch im Browser, jede Seite als Bild.

Portainer. Portainer hat Vollzugriff auf Docker und ist damit auf deinem Server das lohnendste Ziel, nicht Doory. Außerdem stehen Datenbank-Passwort und Secret Key im Klartext in der Stack-Konfiguration. Wer an dein Portainer kommt, sieht sie also.

Mein Fazit zur Sicherheit: Im eigenen Netz, ohne Portfreigabe und mit fester Version halte ich das Risiko für gering.

Alpha: Heimnetz-Sperre mit dem Doorway

Alpha, experimentell: Diese Funktion habe ich nur mit Doory 0.2.0 unter ZimaOS 1.8.0 getestet. Sie greift in den Start von Doory ein und kann mit einem Doory-Update brechen. Für die meisten ist sie nicht nötig.

Doory ist ein junges Projekt, und jedes Update ist ein Vertrauensvorschuss. Wer Doory erst mal nur halb traut, setzt im Generator den Haken bei Heimnetz-Sperre. Dann kommt ein kleiner zusätzlicher Container dazu, der Doorway:

• Alle Doory-Container teilen sich seinen Netzwerk-Zugang. Er ist die einzige Tür nach draußen.
• Er sperrt dein Heimnetz, den Router, andere private Netze und den Server selbst. Das Internet bleibt offen, Schriften, Vorlagen und Pixabay funktionieren also weiter.
• Er braucht keine Rechte auf deinem Server. Seine Regeln gelten nur für seinen eigenen Netzwerk-Zugang, deine anderen Apps bleiben unberührt.
• Die Sperre steht, bevor Doory startet. Auch nach einem Neustart läuft Doory nie ungeschützt.
• Namen löst er über öffentliche DNS-Server auf (Cloudflare und Quad9), nicht über deinen Router.

Ob die Sperre greift, zeigen dir die Zähler:

docker exec doory-doorway iptables -nvL OUTPUT

Steigt die Zahl in einer der DROP-Zeilen, wollte Doory etwas in deinem Netz erreichen und wurde abgewiesen.

Was sich dadurch ändert:

• Der Port hängt am Doorway statt an doory-web. Intern sprechen sich die Dienste über 127.0.0.1 an.
• Damit die Weboberfläche die API findet, schreibt die YAML beim Start von doory-web drei Zeilen in dessen nginx-Konfiguration um. Ändert Doory diese Konfiguration in einer neuen Version, startet doory-web nicht und meldet das im Log. Dann erzeugst du die YAML einfach ohne Haken neu.
• Der Doorway lädt beim Start iptables aus den offiziellen Alpine-Paketen. Ohne Internet startet er nicht, und Doory dann auch nicht.

Umstellen und zurück: Erzeuge die YAML mit oder ohne Haken neu und übernimm Secret Key und Datenbank-Passwort aus deiner bisherigen YAML. Deine Daten in /DATA/AppData/doory/ bleiben erhalten.

Feineinstellungen

Mehr Speicherplatz pro Benutzer

Ohne Anpassung bekommt jeder Benutzer nur 2 GB Speicherplatz. Das habe ich erst gemerkt, als mir Doory die 2 GB im Konto angezeigt hat. In der YAML oben habe ich den Wert deshalb schon auf 50 GB gesetzt (USER_STORAGE_QUOTA_BYTES). Der Wert wird in Bytes angegeben:

Eine einzelne Datei darf übrigens höchstens 25 MB groß sein. Diese Grenze ist fest eingebaut.

Downloads nach dem ersten Start abschalten

Mit DOORY_SYNC_...: "true" prüft Doory bei jedem Neustart, ob alle Inhalte vollständig sind. Nach dem ersten Start geht das schnell. Wenn du die Neustarts ganz schlank halten willst, setze die vier DOORY_SYNC_...-Werte und DOORY_SEED_TEMPLATES auf "false" und klicke im Stack auf Update the stack.

Ein Icon für dein Dashboard

Doory liefert sein Icon selbst aus. Für eine Verknüpfung auf dem ZimaOS-Dashboard oder in einem anderen Dashboard kannst du diese Adresse verwenden:

http://DEINE-IP:8585/icons/icon-192.png

Doory aktualisieren

Mit den offiziellen Images ist ein Update schnell erledigt:

1. Mach vorher ein Backup und lies die Versionshinweise. Dort steht, ob du bei einem Update etwas beachten musst.
2. Im Stack doory die Versionsnummer an den drei image:-Zeilen ändern, zum Beispiel von 0.2.0 auf die neue Version.
3. Auf Update the stack klicken. Portainer lädt die neuen Images und startet die Container neu. Änderungen an der Datenbank spielt doory-api beim Start automatisch ein.

Hast du Doory über den App-Import von ZimaOS oder CasaOS installiert, änderst du die Versionsnummer in den Einstellungen der App. Klappt das nicht, deinstallierst du die App und importierst die YAML mit der neuen Version erneut. Entscheidend ist, dass Secret Key und Datenbank-Passwort gleich bleiben und du den Ordner /DATA/AppData/doory/ nicht löschst.

ZimaOS meldet außerdem von sich aus „Image-Update verfügbar“, auch bei importierten Apps. Du findest das im App Store unter Meine Apps > Aktualisieren. Bei Doory betrifft das nicht Doory selbst, das bleibt auf der eingetragenen Version, sondern zum Beispiel die Datenbank postgres:16-alpine. Das sind kleinere Updates innerhalb von Postgres 16, etwa Sicherheitskorrekturen, die du bedenkenlos einspielen kannst. Was genau ansteht, zeigt dir „Updatedetails“.

Deine Designs und Benutzer bleiben in allen Fällen erhalten, sie liegen in /DATA/AppData/doory/.

Beim Sprung von 0.1.0 auf 0.2.0 kommen rund 1.600 neue Formatgrößen dazu. Einige alte eingebaute Größen wurden dabei korrigiert. Diese übernimmst du optional mit python manage.py seed_size_presets --update in der Konsole von doory-api. Deine eigenen Formate bleiben davon unberührt.

Backup

Sichere den kompletten Ordner /DATA/AppData/doory/. Darin liegen Datenbank, hochgeladene Bilder und Exporte. Am sichersten ist das Backup, wenn du den Stack vorher stoppst.

Willst du Doory dafür nicht anhalten, sicherst du die Datenbank im laufenden Betrieb mit einem Dump, so wie es auch die offizielle Anleitung empfiehlt:

docker exec doory-db pg_dump -U doory -Fc doory > doory-$(date +%F).dump

Dazu kommt der Ordner media. Schriften, Icons und Vorlagen darin kann Doory jederzeit neu herunterladen, deine eigenen Uploads nicht.

Vergiss außerdem die YAML nicht. Darin stehen Secret Key und Datenbank-Passwort, und ohne die beiden passt ein zurückgespieltes Backup nicht mehr zur Installation. Wie du so ein Backup auf ZimaOS automatisierst, zeige ich in meinem Artikel zum Paperless-NGX-Cloud-Backup mit Duplicati.

Fazit: Ist Doory eine echte Canva-Alternative?

Doory ist eine ernstzunehmende App. Wer Canva kennt, findet sich sofort zurecht, der Workflow ist sehr ähnlich. Auch das Freistellen funktioniert für eine kostenlose Software bei einfachen Motiven überraschend gut.

Mit Canva Pro kann Doory aber noch nicht mithalten. Wer wie ich regelmäßig Produktfotos mit unruhigem Hintergrund freistellt, kommt um Canva vorerst nicht herum. Doory steht noch am Anfang seiner Entwicklung und wird mit jeder Version besser. Zwischen 0.1.0 und 0.2.0 lagen gerade einmal vier Tage, und in der Zeit kamen Videoclips, das Hochskalieren von Fotos und die Anmeldung per SSO dazu.

Für wen sich Doory lohnt:

• Du willst deine Designs und Bilder nicht bei einem Cloud-Anbieter ablegen.
• Du brauchst einen Editor für Familie, Verein oder ein kleines Team und willst kein Abo bezahlen.
• Du hast ohnehin einen Homeserver und Lust, ein junges Projekt auszuprobieren.

Wer dagegen täglich auf tausende fertige Vorlagen oder sauber freigestellte Produktfotos angewiesen ist, bleibt vorerst besser bei Canva.

Doory ist Open Source und kostenlos. Wie offen die Entwickler für Wünsche aus der Community sind, hat mein Issue gezeigt. Wenn dir das Projekt gefällt, lass ihnen einen Stern auf GitHub da.

Mehr Self-Hosting-Anleitungen für deinen Homeserver findest du in meiner ZimaOS-Übersicht.