Zum Hauptinhalt springen
S-EDV news
← Alle Anleitungen
📘 Anleitung Docker 22.08.2026 · 12 min Lesezeit Geprüft 02.11.2026

Memos mit Docker installieren: Notizdienst für Schnellnotizen selbst hosten

Memos 26.11 mit Docker Compose selbst hosten: fester Image-Tag, Zugriff und Registrierung sperren, HTTPS per Reverse Proxy, getestete Sicherung, Wiederherstellung und Umstieg von 0.31.

Werbung Mit * markierte Links sind Werbelinks: Bei einem Kauf erhalten wir eine Provision, der Preis bleibt gleich. Als Amazon-Partner verdiene ich an qualifizierten Verkäufen. Mehr dazu

Titelbild: Memos mit Docker installieren, Notizen, Schnell, Privat

Memos ist ein selbst gehosteter Notizdienst für kurze Einträge: Tagesnotizen, Checklisten, Befehle, Links. Er läuft als einzelner Container mit SQLite und eignet sich als interne Notizablage für Einzelpersonen und kleine Teams, die ihre Notizen nicht bei einem Cloud-Anbieter ablegen wollen. Diese Anleitung richtet Memos 26.11.0 mit Docker Compose auf einem Linux-Server ein, sperrt den öffentlichen Zugriff und die Selbstregistrierung und zeigt eine Sicherung samt Wiederherstellung, die im Test nachgestellt wurde.

Voraussetzungen

  • Linux-Server, VM oder Mini-PC mit Docker Engine und Compose-Plugin (docker compose), siehe Docker und Docker Compose auf Linux installieren.
  • Architektur x86_64 (amd64) oder ARM (arm64, arm/v7, etwa Raspberry Pi 4 oder 5).
  • 1 CPU-Kern und 512 MB freier Arbeitsspeicher reichen. Im Test belegte der Container im Leerlauf rund 16 MB RAM, das Image rund 106 MB Platte.
  • 1 GB Speicherplatz für Datenbank und Anhänge, bei vielen Bildern oder PDF-Anhängen entsprechend mehr.
  • Für den Zugriff von anderen Geräten: eine Subdomain wie memos.example.com mit DNS-Eintrag auf den Server und ein Reverse Proxy, siehe Schritt 4.
EckdatenWert
Imageneosmemo/memos:26.11.0 (Docker Hub)
Port im Container5230 (HTTP, Variable MEMOS_PORT)
Datenpfad/var/opt/memos mit memos_prod.db und Anhängen
Benutzer im Containerstartet als root, wechselt auf UID/GID 10001 (MEMOS_UID, MEMOS_GID)
Wichtige VariablenMEMOS_INSTANCE_URL, MEMOS_DRIVER (sqlite, mysql, postgres), MEMOS_DSN

Schritt 1: Projektordner, .env und compose.yaml anlegen

Alle Dateien liegen in einem eigenen Ordner, die Daten im Unterordner memos-data. Einen chown brauchen Sie nicht: Das Startskript des Images setzt den Eigentümer des Datenordners selbst auf UID 10001 und arbeitet danach ohne root-Rechte weiter. Im Test meldete der Container beim Start memos: starting as UID:GID 10001:10001, und der vorher von einem normalen Benutzer angelegte Ordner gehörte danach UID 10001.

$ sudo mkdir -p /opt/memos/memos-data
$ cd /opt/memos

Die .env enthält nur die öffentliche Adresse. Memos nutzt sie für Links, etwa beim Teilen einzelner Notizen. SQLite ist der Standard, dafür ist keine weitere Variable nötig:

# /opt/memos/.env
# Öffentliche Adresse der Instanz (später der Reverse Proxy)
MEMOS_INSTANCE_URL=https://memos.example.com

Die compose.yaml legt die Version fest, bindet den Port nur an die Loopback-Schnittstelle und prüft den eingebauten Endpunkt /healthz. Das Image basiert auf Alpine und bringt wget mit, der Healthcheck funktioniert deshalb ohne Zusatzpakete:

services:
  memos:
    image: neosmemo/memos:26.11.0
    container_name: memos
    restart: unless-stopped
    ports:
      - "127.0.0.1:5230:5230"
    volumes:
      - ./memos-data:/var/opt/memos
    env_file:
      - .env
    healthcheck:
      test: ["CMD", "wget", "-q", "--spider", "http://localhost:5230/healthz"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 20s

Zum Tag: Das offizielle Beispiel im Repository nutzt neosmemo/memos:stable. Dieser Tag zeigt immer auf die neueste stabile Version und aktualisiert damit bei jedem pull ungefragt, inklusive Datenbankmigration. Ein fester Tag wie 26.11.0 macht Updates zu einer bewussten Entscheidung. Seit 26.10.0 nutzt Memos Kalenderversionen ohne v-Präfix (26.10.0, 26.10.1); die frühere Reihe hieß v0.x. canary und Vorabversionen wie 26.11-rc.1 sind Entwicklungsstände und gehören nicht auf einen Produktivserver.

docker compose config -q im Ordner /opt/memos endet ohne Ausgabe und mit Exit-Code 0. Bei einem Tippfehler in der YAML-Datei nennt der Befehl Zeile und Fehler.

Schritt 2: Memos starten und prüfen

$ cd /opt/memos
$ docker compose up -d
$ docker compose ps
$ docker compose logs memos

Im Test war der Container nach weniger als zehn Sekunden healthy. Die Logs einer neuen Instanz enthalten unter anderem:

memos: starting as UID:GID 10001:10001
level=INFO msg="database initialized successfully" schemaVersion=26.10.1
Memos 26.11.0 started successfully!
Database driver: sqlite
Server running on port 5230
Access mode: public

Die letzte Zeile ist kein Fehler, aber ein Arbeitsauftrag: Ist MEMOS_INSTANCE_URL beim ersten Start gesetzt, legt Memos den Zugriffsmodus auf öffentlich fest (so steht es im Migrationscode, store/migrator.go). Ohne die Variable startet die Instanz privat. Schritt 3 stellt den Modus um.

$ curl -I http://127.0.0.1:5230
$ curl -s http://127.0.0.1:5230/healthz
$ ss -tlnp | grep 5230

docker compose ps zeigt Up … (healthy) und 127.0.0.1:5230->5230/tcp. curl -I liefert HTTP/1.1 200 OK, /healthz antwortet mit Service ready., und ss zeigt nur 127.0.0.1:5230, nicht 0.0.0.0:5230.

Schritt 3: Administrator anlegen, Zugriff und Registrierung sperren

Ohne Reverse Proxy erreichen Sie die Oberfläche über einen SSH-Tunnel von Ihrem Arbeitsrechner aus:

$ ssh -L 5230:127.0.0.1:5230 benutzer@server

Öffnen Sie dann http://localhost:5230. Auf einer neuen Instanz erscheint die Registrierung. Der erste Benutzer, den Sie dort anlegen, erhält die Rolle Administrator; im Test zeigte die API für dieses Konto "role":"ADMIN". Legen Sie das Konto deshalb sofort nach dem Start an, bevor jemand anderes die Seite erreicht.

Danach ist die Instanz noch offen: Im Test konnte sich direkt nach dem Administrator ein zweites Konto ohne Anmeldung selbst registrieren, und die Notizliste der API war ohne Login abrufbar (HTTP 200). Stellen Sie beides um. Die Oberfläche ist in der getesteten Version auch bei deutscher Browsersprache nach der Anmeldung teilweise englisch beschriftet:

  1. Klicken Sie unten links auf Ihren Benutzernamen und öffnen Sie Settings (Einstellungen).
  2. Wählen Sie im Bereich ADMIN den Punkt System.
  3. Schalten Sie unter Access and policies den Schalter Allow public access aus.
  4. Schalten Sie Disallow user registration ein.
Memos-Einstellungen System mit deaktiviertem öffentlichem Zugriff und gesperrter Registrierung
Einstellungen, Bereich System: öffentlicher Zugriff aus, Selbstregistrierung gesperrt.

Öffentlich geteilte Einzel-Links funktionieren auch im privaten Modus weiter, das beschreibt die Oberfläche direkt am Schalter. Für eine reine interne Ablage legen Sie neue Notizen mit der Sichtbarkeit Private an; das ist im Editor die Voreinstellung.

Memos-Startseite mit Eingabefeld, drei privaten Notizen und Tag-Liste in der Seitenleiste
Startseite von Memos mit Editor, drei privaten Notizen und den daraus erzeugten Tags in der Seitenleiste.

Ohne Anmeldung liefert curl -s -o /dev/null -w '%{http_code}' http://127.0.0.1:5230/api/memos jetzt 401 statt 200. Ein Registrierungsversuch in einem privaten Browserfenster scheitert; die API meldet user registration is not allowed. Nach einem Neustart steht in den Logs Access mode: private.

Schritt 4: HTTPS über einen Reverse Proxy

Memos spricht selbst nur HTTP. Für den Zugriff aus dem Netz stellen Sie einen Reverse Proxy auf demselben Host davor, der das Zertifikat verwaltet und an 127.0.0.1:5230 weiterleitet. Mit Caddy reicht ein Eintrag im Caddyfile, das Zertifikat von Let's Encrypt holt Caddy automatisch, sobald der DNS-Eintrag stimmt und die Ports 80 und 443 erreichbar sind (Details: Caddy als Reverse Proxy einrichten):

memos.example.com {
    reverse_proxy 127.0.0.1:5230
}

Laufen auf dem Server mehrere Container-Dienste, ist Traefik als Docker-Reverse-Proxy eine Alternative. Achten Sie darauf, dass die MEMOS_INSTANCE_URL in der .env genau der Adresse entspricht, unter der Memos erreichbar ist. Nach einer Änderung der .env erstellen Sie den Container neu:

$ cd /opt/memos
$ docker compose up -d --force-recreate

curl -I https://memos.example.com liefert Status 200 mit gültigem Zertifikat, der Browser zeigt die Anmeldeseite ohne Warnung, und ein geteilter Link einer Notiz beginnt mit https://memos.example.com.

Schritt 5: Sichern und Wiederherstellen

Der Ordner memos-data enthält die Datenbank memos_prod.db und, sobald Sie Dateien anhängen, deren Ablage. Im laufenden Betrieb hält SQLite einen Teil der Änderungen in den Dateien memos_prod.db-wal und -shm; ein Kopieren im Betrieb kann deshalb einen unvollständigen Stand sichern. Stoppen Sie den Container kurz, dann schreibt SQLite alles in die Hauptdatei:

$ cd /opt/memos
$ sudo mkdir -p /backup/memos
$ docker compose stop memos
$ sudo tar -czf /backup/memos/memos-$(date +%F).tar.gz memos-data .env compose.yaml
$ docker compose start memos

Im Test enthielt das Archiv nach dem Stopp nur noch memos_prod.db ohne WAL-Dateien. Für Sicherungen außer Haus mit Versionierung eignet sich restic mit automatischer Sicherung per Cron, das das Archiv oder direkt den Ordner übernimmt.

Eine Sicherung zählt erst, wenn die Wiederherstellung funktioniert. So stellen Sie einen Stand zurück:

$ cd /opt/memos
$ docker compose down
$ sudo mv memos-data memos-data.alt
$ sudo tar -xzf /backup/memos/memos-2026-10-14.tar.gz memos-data
$ docker compose up -d

Im Test wurde eine Notiz mit einem Marker angelegt, gesichert, danach gelöscht und anschließend aus dem Archiv zurückgeholt. Nach dem Start war der Container wieder healthy, die gelöschte Notiz war wieder da, Zugriffsmodus und Registrierungssperre blieben erhalten, weil sie in derselben Datenbank stehen. Den Ordner memos-data.alt löschen Sie erst, wenn der zurückgeholte Stand stimmt.

tar -tzvf auf das Archiv listet memos-data/memos_prod.db mit Eigentümer 10001, .env und compose.yaml. Nach einer Probe-Wiederherstellung zeigt docker compose ps wieder (healthy), und Ihre letzte Notiz vor der Sicherung ist in der Oberfläche sichtbar.

Schritt 6: Updates einspielen

Memos passt beim Start das Datenbankschema automatisch an die neue Version an. Zurück auf eine ältere Version führt danach nur die Sicherung aus Schritt 5. Gehen Sie deshalb in dieser Reihenfolge vor:

  1. Release Notes aller übersprungenen Versionen auf GitHub lesen.
  2. Sicherung wie in Schritt 5 anlegen.
  3. Tag in der compose.yaml ändern, etwa auf die nächste stabile Version.
  4. Neues Image laden und Container neu erstellen.
$ cd /opt/memos
$ docker compose pull
$ docker compose up -d
$ docker image prune -f

Für ältere Installationen gilt laut Release Notes ein fester Upgrade-Pfad: Instanzen vor 0.31.0 laufen zuerst einmal erfolgreich mit 0.31.0, Instanzen vor 0.22 vorher zusätzlich mit 0.25.3. Von 0.31.0 aus geht der Sprung auf 26.10.0 direkt.

Update von 26.10.0 auf 26.11.0: Laut Release Notes behebt 26.11.0 die Eingabe japanischer und koreanischer Zeichen in Safari, meldet nicht lesbare Anhänge als JSON-Fehler (fehlende lokale Dateien mit 404) und hält den Zwischenspeicher des Servers unter Last in seiner Größengrenze. Wer von 0.31 kommt und noch Dateien unter /etc/secrets (memos-idp-*.json, memos-instance-setting-*.json) liegen hat, sieht jetzt beim Start eine Warnung mit dem Dateinamen: Diese Dateien liest Memos seit 26.10.0 nicht mehr, ihre Einstellungen gehören nach /etc/memos/config. Im Test mit der Compose-Datei dieser Anleitung lief das Update ohne Eingriff: Der Container war nach wenigen Sekunden healthy, das Log meldete Memos 26.11.0 started successfully!, die Marker-Notiz, der private Zugriffsmodus und die gesperrte Registrierung blieben erhalten, ein Zugangstoken aus 26.10.0 galt weiter, ein falsches Passwort gab HTTP 400, und eine unter 26.10.0 angelegte Sicherung ließ sich unter 26.11.0 zurückspielen.

Umstieg von 0.31 auf 26.10

26.10.0 ist der erste Release mit Kalenderversion und bringt mehrere Änderungen, die Bestandsinstallationen betreffen (laut Release Notes):

  • Neue API-Pfade: Die REST-API liegt jetzt unter /api/… statt /api/v1/…. Die alten Pfade antworten mit HTTP 410. Eigene Skripte und Integrationen müssen Pfade und umbenannte Felder anpassen.
  • Erneute Anmeldung: Zugangstoken sind jetzt an das Passwort gebunden. Zwischengespeicherte Access-Tokens verfallen beim Update, Browser-Sitzungen erneuern sich still, API-Clients mit Access-Token müssen sich neu anmelden. Persönliche Zugangstoken bleiben gültig.
  • Limits: Die beiden alten Einstellungen für Notizlänge und Upload-Größe entfallen, ihre Werte werden nicht übernommen. Ab Werk gelten 8 KiB je Notiz und 32 MiB je Datei; abweichende Werte setzen Sie unter Settings, Usage limits neu.
  • Konfigurationsdateien: Die in 0.31.0 eingeführten Dateien unter /etc/secrets (memos-idp-*.json, memos-instance-setting-*.json) liest Memos nicht mehr. Wer sie genutzt hat, überführt sie in das neue Konfigurationsverzeichnis.
  • Export: Den Export von Notizen dürfen nur noch Administratoren auslösen.
  • Editor: Der Editor startet im Rich-Text-Modus; den reinen Markdown-Modus schalten Sie unter Settings, Editor ein. Die eingebaute Aufgabenansicht entfällt.

Im Test wurde eine Instanz mit 0.31.0 und der Compose-Datei dieser Anleitung angelegt: Administrator, privater Zugriffsmodus, gesperrte Registrierung und eine Marker-Notiz, danach eine Sicherung nach Schritt 5. Nach dem Wechsel des Tags auf 26.10.0 startete der Container in wenigen Sekunden healthy, das Log meldete Memos 26.11.0 started successfully! und Access mode: private. Die Marker-Notiz war vorhanden, Zugriffsmodus und Registrierungssperre blieben erhalten, die Anmeldung mit dem bisherigen Passwort funktionierte, ein falsches Passwort wurde mit 400 abgewiesen, ein vor dem Update ausgestelltes Access-Token bekam 401 und der alte Pfad /api/v1/memos 410. Auch die unter 0.31.0 angelegte Sicherung ließ sich zurückspielen; 26.10.0 migrierte sie beim Start, und die Marker-Notiz war wieder da. Eine Neuinstallation mit 26.10.0 verhielt sich wie in Schritt 2 und 3 beschrieben: öffentlicher Modus beim ersten Start mit gesetzter MEMOS_INSTANCE_URL, offene Registrierung bis zur Sperre.

docker compose ps zeigt den neuen Tag und (healthy), docker compose logs memos enthält die neue Versionsnummer in der Zeile started successfully und keine Migrationsfehler, und Ihre bisherigen Notizen sind vorhanden.

Grundlagen zum Betrieb finden Sie in Linux-Server absichern mit UFW und Fail2ban und Docker-Container automatisch aktualisieren: Diun, WUD und Renovate im Vergleich.

Typische Fehler

Fremde können Notizen lesen oder Konten anlegen

Neue Instanz mit gesetzter MEMOS_INSTANCE_URL startet öffentlich und mit offener Registrierung. Lösung: Schritt 3, danach mit curl auf /api/memos den Status 401 prüfen.

Container bleibt unhealthy

Der Healthcheck fragt http://localhost:5230/healthz im Container ab. Haben Sie MEMOS_PORT geändert, passen Sie die Adresse im Healthcheck an.

bind: address already in use auf Port 5230

Ein anderer Dienst belegt den Port. Ändern Sie nur den Host-Port, etwa "127.0.0.1:5231:5230", und passen Sie den Reverse Proxy an.

Rechtefehler im Datenordner, etwa bei rootless Docker oder NFS

Das Startskript ändert den Eigentümer nur, wenn der Container als root startet und das Dateisystem es zulässt. Setzen Sie dann MEMOS_UID und MEMOS_GID passend zu den Rechten des Ordners.

Daten nach Neustart verschwunden

Die Volume-Zeile ./memos-data:/var/opt/memos fehlt oder zeigt auf einen anderen Ordner. Dann schreibt Memos in den Container selbst, und docker compose down löscht alles.

Geteilte Links zeigen auf localhost oder eine alte Domain

MEMOS_INSTANCE_URL fehlt oder ist veraltet. Wert korrigieren und docker compose up -d --force-recreate.

Nach einem Update veraltete Oberfläche

Der Browser hält alte Dateien im Cache. Ein erzwungenes Neuladen mit Strg+Umschalt+R behebt das.

Häufige Fragen

Brauche ich eine externe Datenbank?

Nein. SQLite reicht für Einzelpersonen und kleine Teams und ist die Voreinstellung. MySQL oder PostgreSQL lohnen sich, wenn Sie ohnehin einen gepflegten Datenbankserver mit eigener Sicherung betreiben. Dann setzen Sie MEMOS_DRIVER auf mysql oder postgres und den Verbindungsstring in MEMOS_DSN; den Datenordner brauchen Sie trotzdem für Anhänge.

Kann ich das Passwort der Datenbank als Docker-Secret übergeben?

Ja. Das Startskript liest statt MEMOS_DSN auch MEMOS_DSN_FILE, also eine Datei mit dem Verbindungsstring. Beide Variablen gleichzeitig zu setzen führt zu einem Startfehler.

Wie lege ich weitere Benutzer an, wenn die Registrierung gesperrt ist?

Als Administrator in den Einstellungen im Bereich Member.

Läuft Memos auf einem Raspberry Pi?

Ja, das Image gibt es für arm64 und arm/v7. Die compose.yaml bleibt unverändert, Docker wählt die passende Variante selbst.

Was unterscheidet Memos von einem Wiki?

Memos ist für kurze, chronologische Einträge mit Tags gedacht, ähnlich einem privaten Microblog. Für strukturierte Dokumentation mit Kapiteln, Rechten je Bereich und Versionsverlauf eignet sich ein Wiki wie BookStack oder ein Arbeitsbereich wie AFFiNE besser.

Fazit

Memos ist mit einem Container und einer SQLite-Datei in wenigen Minuten betriebsbereit und braucht kaum Ressourcen. Der kritische Moment ist der erste Start: Mit gesetzter Instanz-URL ist die Instanz öffentlich und die Registrierung offen, bis Sie beides abschalten. Mit festem Image-Tag, HTTPS über einen Reverse Proxy, gesperrter Registrierung und einer geprüften Sicherung vor jedem Update ist Memos eine solide interne Notizablage.

Weiterführende Anleitungen und Quellen