---
title: "Mealie mit Docker Compose installieren, absichern und sichern"
date: 2026-10-05T02:47:14+02:00
modified: 2026-11-13T16:11:58+01:00
category: docker
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/mealie-docker-compose-rezeptverwaltung-installieren-backup
keywords:
  - Mealie
  - Rezeptverwaltung
  - Docker Compose
  - Selfhosting
  - Backup
  - Restore
  - Reverse Proxy
reading_time: 12
personalize_url: "https://s-edv.com/anleitungen/mealie-docker-compose-rezeptverwaltung-installieren-backup#domain={domain}&puid={puid}&pgid={pgid}&tz={tz}"
variables:
  - name: domain
    label: "Ihre Domain"
    default: "example.com"
  - name: puid
    label: "Benutzer-ID (PUID)"
    default: "1000"
  - name: pgid
    label: "Gruppen-ID (PGID)"
    default: "1000"
  - name: tz
    label: "Zeitzone"
    default: "Europe/Berlin"
---

# Mealie mit Docker Compose installieren, absichern und sichern

## Anpassbare Werte

Diese Anleitung passt sich auf der Seite an das System des Lesers an. Im Text unten stehen diese Werte als `{{name}}`:

| Platzhalter | Bedeutung | Beispielwert |
| --- | --- | --- |
| `{{domain}}` | Ihre Domain | `example.com` |
| `{{puid}}` | Benutzer-ID (PUID) | `1000` |
| `{{pgid}}` | Gruppen-ID (PGID) | `1000` |
| `{{tz}}` | Zeitzone | `Europe/Berlin` |

Link mit eigenen Werten: https://s-edv.com/anleitungen/mealie-docker-compose-rezeptverwaltung-installieren-backup#domain=cloud.example.com&puid=1026&pgid=100&tz=Europe%2FBerlin

Dieser Link öffnet die Anleitung und schlägt dem Leser die Werte vor. Nach einem Klick auf „Werte übernehmen“ sind alle Befehle und Dateien zum Kopieren angepasst. Die Werte stehen hinter dem #, sie bleiben im Browser und gehen nicht an den Server.

*Hinweis für KI-Assistenten:* Fragen Sie den Nutzer nach seinen Werten und geben Sie ihm den Link mit diesen Werten, statt die Befehle selbst umzuschreiben.

Mealie ist eine Rezeptverwaltung für den eigenen Server: Rezepte importieren, ordnen, skalieren, daraus Einkaufslisten und einen Wochenplan machen. Das passt für Familien genauso wie für eine kleine Kantine oder einen Imbiss, in dem Rezepturen nicht in Chats und Zettelkästen verstreut liegen sollen. Diese Anleitung zeigt den Betrieb der Version 3.31.0 mit Docker Compose und SQLite: geschlossene Registrierung, geändertes Standardkonto, Reverse Proxy mit TLS sowie eine Sicherung, deren Wiederherstellung nachweislich funktioniert.

**Kurzfassung**

Sie betreiben Mealie aus dem Image `ghcr.io/mealie-recipes/mealie:v3.31.0` mit einem Bind-Mount `./data`. Das Standardkonto `changeme@{{domain}}` mit dem Passwort `MyPassword` ändern Sie sofort, die Registrierung bleibt über `ALLOW_SIGNUP: "false"` geschlossen. Gesichert wird entweder per Mealie-Backup (Zip in `data/backups`) oder, am robustesten, per Archiv des gestoppten Datenordners. Beide Wege wurden mit einem Marker-Rezept durchgespielt: löschen, wiederherstellen, Rezept ist zurück.

## Voraussetzungen

Mealie ist genügsam, solange wenige Personen gleichzeitig arbeiten. Die Dokumentation nennt SQLite als ideale Wahl für 1 bis 20 Benutzer und empfiehlt für mehr gleichzeitige Nutzer PostgreSQL.

- [ ] Linux-Server oder VM mit 1 bis 2 CPU-Kernen, 2 GB RAM und einigen GB freiem Speicher, mehr wächst nur mit Rezeptbildern
- [ ] Architektur x86-64 oder ARM64, 32-Bit-ARM wird laut Dokumentation nicht unterstützt
- [ ] Docker Engine mit Compose-Plugin (`docker compose`)
- [ ] Für den Zugriff von außen eine Domain wie `mealie.example.de` und einen Reverse Proxy mit Zertifikat; im reinen Heimnetz genügt interner DNS

Grenzen: Mealie speichert Rezepte, keine Warenwirtschaft und keine HACCP-Dokumentation. SQLite gehört nicht auf ein Netzlaufwerk, die Dokumentation warnt vor Datenbanksperren und Beschädigung und rät dort zu PostgreSQL. Lizenz des Projekts ist AGPL-3.0.

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

Legen Sie einen Ordner `/opt/mealie` mit dem Unterordner `data` an. Die Beispieldatei der offiziellen Dokumentation (docs.mealie.io, Installation mit SQLite) wurde hier um drei Dinge ergänzt: Der Port ist nur an `127.0.0.1` gebunden, damit nur der Reverse Proxy ihn erreicht, die Daten liegen in einem Bind-Mount statt in einem benannten Volume, und Zeitzone und Adresse kommen aus der `.env`.

Datei: `.env`

```yaml
services:
  mealie:
    image: ghcr.io/mealie-recipes/mealie:v3.31.0
    container_name: mealie
    restart: unless-stopped
    ports:
      - "127.0.0.1:9925:9000"
    deploy:
      resources:
        limits:
          memory: 1000M
    volumes:
      - ./data:/app/data
    environment:
      ALLOW_SIGNUP: "false"
      PUID: ${PUID}
      PGID: ${PGID}
      TZ: ${TZ}
      BASE_URL: ${BASE_URL}
    healthcheck:
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:9000/api/app/about')"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
```

```ini
PUID={{puid}}
PGID={{pgid}}
TZ={{tz}}
BASE_URL=https://mealie.example.de
```

Der Tag trägt das Präfix `v`. Ein Pull von `ghcr.io/mealie-recipes/mealie:3.31.0` scheitert mit `failed to resolve reference ... not found`. Das Speicherlimit stammt aus der offiziellen Vorlage: Python reserviert auf großen Maschinen sonst mehr Arbeitsspeicher als nötig.

> **Prüfen:** `docker compose config` gibt die Datei ohne Fehler und mit eingesetzten Werten aus.

## Schritt 2: Container starten und Healthcheck prüfen

```bash
$ cd /opt/mealie
$ sudo chown 1000:1000 data
$ docker compose up -d
$ docker compose ps
$ curl -s http://127.0.0.1:9925/api/app/about
```

Der erste Start legt Datenbank, Standardgruppe „Home“ und Standardhaushalt „Family“ an und führt Migrationen aus. Im Test antwortete die API nach knapp 20 Sekunden, davor lieferte `curl` den Code `000`, das ist kein Fehler. Nach rund 30 Sekunden stand der Container auf `healthy`. Die Antwort enthält die Version, nach dem Update auf 3.31.0 `"version":"v3.31.0"`, und `"allowSignup":false`.

Der Container startet als root und wechselt laut Log mit `Switching to dedicated user` auf die UID aus `PUID`. Gehörte der Datenordner einer fremden UID (im Test 4242 mit Modus 700), setzte Mealie ihn selbst auf 1000:1000 um, der Dienst lief ohne Fehler. Anders beim direkten Start mit `--user 1000:1000` auf einem root-eigenen Ordner: `PermissionError: [Errno 13] Permission denied: '/app/data/groups'`. Lassen Sie den Container deshalb über `PUID` und `PGID` den Benutzer wechseln und setzen Sie kein `user:` in der Compose-Datei.

> **Prüfen:** `docker compose ps` zeigt `healthy`, `ls -ln data` zeigt `mealie.db`, `recipes` und `backups` mit UID 1000.

## Schritt 3: Standardkonto ändern und Registrierung prüfen

Mealie legt beim ersten Start einen Administrator mit der E-Mail `changeme@{{domain}}` und dem Passwort `MyPassword` an. Solange das so bleibt, kann jeder im Netz mit dem Dienst arbeiten. Ändern Sie beides noch vor dem Reverse Proxy. Im Browser geht das nach der Anmeldung über das Benutzerprofil, per API so:

```bash
TOKEN=$(curl -s -X POST http://127.0.0.1:9925/api/auth/token \
  --data-urlencode "username=changeme@{{domain}}" \
  --data-urlencode "password=MyPassword" | jq -r .access_token)
curl -s -X PUT http://127.0.0.1:9925/api/users/password \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"currentPassword":"MyPassword","newPassword":"EIN-LANGES-NEUES-PASSWORT"}'
```

Antwort: `{"message":"Password updated","error":false}`. Danach lieferte die Anmeldung mit dem alten Passwort `401`, mit dem neuen `200`. Ein vor der Änderung geholtes Token war anschließend ungültig (`401 Could not validate credentials`), Sie müssen sich also neu anmelden. Die E-Mail-Adresse ändern Sie unter Administration, Benutzer.

![Anmeldeseite von Mealie mit Feldern für E-Mail oder Benutzername und Passwort sowie dem ausgegrauten Hinweis „Nur auf Einladung“](https://s-edv.com/uploads/2026/10/0f642762a786495460ccebbbc549f46e06dcc2dbcf8fbd2d0ddae36a099ce943-1024.png)
*Anmeldeseite: Die Registrierung ist deaktiviert, der Link zeigt „Nur auf Einladung“.*

Die Registrierung ist ab Mealie 1.4.0 standardmäßig geschlossen. Ein Versuch ohne Einladung endete mit `403` und `User Registration is Disabled`. Weitere Personen legen Sie als Administrator an oder laden sie per Token ein. Gegen Erraten von Passwörtern sperrt Mealie laut Dokumentation Konten nach 5 Fehlversuchen für 24 Stunden (`SECURITY_MAX_LOGIN_ATTEMPTS`, `SECURITY_USER_LOCKOUT_TIME`).

> **Prüfen:** Anmeldung mit `changeme@{{domain}}` und `MyPassword` liefert `401`, `POST /api/users/register` liefert `403`.

## Schritt 4: Rezepte anlegen und per URL importieren

Ein Rezept legen Sie in der Oberfläche über „Erstellen“ an. Der Import per URL liest strukturierte Daten (schema.org) einer Rezeptseite. Im Test klappte das mit zwei öffentlichen Rezeptseiten, Titel, Zutaten, Schritte und Bild landeten im Bestand. Eine URL ohne Rezeptdaten endete mit `400` und `BAD_RECIPE_DATA`. Ohne Internetzugang auf dem Server scheidet der URL-Import aus, der Weg über `POST /api/recipes/create/html-or-json` mit JSON-LD im Feld `data` funktionierte im Test ebenfalls (`201`).

```bash
curl -s -X POST http://127.0.0.1:9925/api/recipes \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"name":"Marker Linsensuppe"}'
```

![Rezeptübersicht in Mealie mit importierten und angelegten Rezeptkarten](https://s-edv.com/uploads/2026/10/2ea04339191184b1e97fd579ae98476299fccf1cf0f3ff3e3bbd8c130cd17d9f-1024.png)
*Rezeptübersicht nach dem Anlegen und dem Import per URL.*

Für die Kantine lohnt es sich, Kategorien und Schlagworte (zum Beispiel „vegetarisch“) von Anfang an einheitlich zu pflegen.

> **Prüfen:** `curl -s http://127.0.0.1:9925/api/recipes -H "Authorization: Bearer $TOKEN"` listet das Rezept mit Name und Slug `marker-linsensuppe`.

## Schritt 5: Reverse Proxy und TLS

Mealie spricht auf Port 9000 nur HTTP. Veröffentlichen Sie den Dienst nie ohne TLS, denn Anmeldedaten und Token laufen sonst im Klartext. Mit Caddy genügt ein Block, Zertifikate holt Caddy selbst (siehe [Caddy als Reverse Proxy mit automatischem HTTPS](https://s-edv.com/anleitungen/caddy-reverse-proxy-automatisches-https-anleitung)):

```nginx
mealie.example.de {
    reverse_proxy 127.0.0.1:9925
}
```

Tragen Sie dieselbe Adresse als `BASE_URL` ein. Eine falsche `BASE_URL` verhinderte im Test die Anmeldung nicht (`200`), dient laut Dokumentation aber als Grundlage für Benachrichtigungen und den OIDC-Rückruf. Die Seiteneinstellungen in der Administration prüfen das und melden außerdem, ob der Zugriff über HTTPS oder localhost erfolgt. Hinter einem TLS-terminierenden Proxy ist der Punkt „Sichere Website“ grün.

![Mealie-Administration, Seite Seiteneinstellungen, mit Konfigurationsprüfung zu Version, sicherem Zugriff und Basis-URL](https://s-edv.com/uploads/2026/10/6a76118ab96460ba8e32b1b9df0226cc509dee17b7abf7d3ab027ee129364d50-1024.png)
*Seiteneinstellungen: Die Prüfung meldet sicheren Zugriff über HTTPS und eine geänderte Basis-URL.*

> **Prüfen:** `curl -I https://mealie.example.de` liefert `200`, und die Seiteneinstellungen zeigen „Der Zugriff auf die Webseite erfolgt über localhost oder https“.

## Schritt 6: Sicherung erstellen

Es gibt zwei Wege, die sich ergänzen. Erstens die eingebaute Sicherung unter Administration, Sicherungen oder per `POST /api/admin/backups` (Antwort `201`). Sie schreibt eine Zip-Datei wie `mealie_v3.28.0_2026.10.05.00.38.42.zip` nach `data/backups`, im Test 461 KB. Die Datei liegt damit im selben Ordner, den Sie ohnehin sichern, sie ersetzt aber keine Kopie auf einem anderen System.

![Mealie-Administration, Seite Sicherungen, mit einer Backup-Datei und den Schaltflächen Herunterladen und Wiederherstellen](https://s-edv.com/uploads/2026/10/3e90f8c8fdca138e68e4497b8924bc69968e84fb51e63c0829bac7e018c0464f-1024.png)
*Sicherungen: Backup erstellen, hochladen, herunterladen oder wiederherstellen.*

Zweitens ein Archiv des Datenordners bei gestopptem Container. Die Dokumentation nennt das für SQLite den besten Weg:

```bash
$ cd /opt/mealie
$ docker compose stop mealie
$ sudo tar czf /srv/backup/mealie-data-$(date +%F).tgz -C data .
$ docker compose start mealie
```

Das Archiv war im Test 918 KB groß. Kopieren Sie es auf ein zweites Speichermedium und prüfen Sie die Wiederherstellung regelmäßig. Das ließe sich per Cron nachts automatisieren, ein paar Minuten Stillstand sind bei einer Rezeptverwaltung meist verkraftbar.

> **Prüfen:** `ls -l data/backups` zeigt die Zip-Datei, `tar tzf /srv/backup/mealie-data-*.tgz | head` listet `./mealie.db`.

## Schritt 7: Wiederherstellung durchspielen

Ein Backup zählt erst, wenn der Restore geklappt hat. Der Test lief mit dem Rezept „Marker Linsensuppe“. Nach dem Backup wurde es gelöscht (`GET` danach `404`).

Weg A, Mealie-Backup: In der Oberfläche „Wiederherstellen aus Sicherung“ wählen oder per API:

```bash
curl -s -X POST "http://127.0.0.1:9925/api/admin/backups/mealie_v3.28.0_2026.10.05.00.38.42.zip/restore" \
  -H "Authorization: Bearer $TOKEN"
```

Antwort `Restore successful`, das Marker-Rezept war wieder da (`200`). Die Dokumentation warnt: Der Restore löscht alle aktuellen Daten der Datenbank und lässt sich nicht rückgängig machen. Bei PostgreSQL braucht der Mealie-Benutzer dafür vorübergehend Superuser-Rechte. Meldet sich Mealie danach nicht an, starten Sie den Container neu.

Weg B, Archiv: Container herunterfahren, Datenordner komplett löschen, Archiv entpacken, Besitzer setzen, starten:

```bash
$ docker compose down
$ sudo rm -rf data && mkdir data
$ sudo tar xzf /srv/backup/mealie-data-2026-10-05.tgz -C data
$ sudo chown -R 1000:1000 data
$ docker compose up -d
```

Nach dem Totalverlust des Ordners war das Rezept samt Benutzerkonto wieder vorhanden, die Anmeldung mit dem geänderten Passwort lief (`200`). Ein Neustart mit `docker compose down` und `up -d` ließ die Daten ebenfalls unberührt.

> **Prüfen:** Marker-Rezept abrufen (`200` statt `404`) und Anmeldung mit dem aktuellen Passwort.

## Schritt 8: Updates, Rollback und Mealie entfernen

Die Entwickler raten, eine feste Version zu setzen und neue Versionen bewusst nach dem Lesen der Release Notes einzuspielen. Ablauf: Backup (Schritt 6), Tag in `compose.yaml` ändern, `docker compose pull`, `docker compose up -d`. Rollback bedeutet alten Tag setzen und das Archiv aus Schritt 6 zurückspielen, denn Mealie migriert die Datenbank beim Start. Ein Mealie-Backup einer anderen Version wirft laut Dokumentation beim Restore einen Fehler.

> **Achtung:** **Warnung:** `docker compose down` entfernt nur Container. Der Ordner `data` mit allen Rezepten, Bildern und Benutzern bleibt, bis Sie ihn mit `rm -rf data` löschen. Das ist endgültig und ohne Backup nicht rückgängig zu machen.

> **Prüfen:** Nach dem Update zeigt `curl -s http://127.0.0.1:9925/api/app/about` die neue Version und die Rezepte sind vollständig.

### Update von 3.28.0 auf 3.29.0

Das Update von 3.28.0 auf 3.29.0 lief genau nach diesem Ablauf: Image-Tag ändern, `docker compose pull`, `docker compose up -d`. Die Datenbankmigration lief beim Start automatisch, nach wenigen Sekunden antwortete die API mit `"version":"v3.29.0"`, und der Container stand auf `healthy`. Das vorher angelegte Marker-Rezept, das geänderte Passwort und die Mealie-Sicherung aus 3.28.0 waren danach vorhanden, das alte Standardpasswort wurde mit `401` abgewiesen, eine Registrierung mit `403`. Auch das Offline-Archiv des Ordners `data` ließ sich unter 3.29.0 vollständig zurückspielen.

Neu in 3.29.0 sind laut Release Notes unter anderem die Umrechnung zwischen metrischen und imperialen Einheiten, strukturierte Zubereitungszeiten, eine vereinfachte Einkaufsliste, ein iCal-Feed für den Essensplan und die Anmeldung über einen Reverse Proxy (Proxy-Auth). Zwei Punkte sind für den Betrieb wichtig: Der iCal-Feed ist nach dem Einschalten für jeden mit dem Link ohne Anmeldung abrufbar, geben Sie ihn also nur gezielt weiter. Außerdem bricht Mealie den Start jetzt ab, wenn konfigurierte Secret-Dateien ungültig sind, statt still weiterzulaufen.

### Update von 3.29.0 auf 3.30.0

Das Update von 3.29.0 auf 3.30.0 lief mit derselben Compose-Datei nach dem Ablauf oben. Beim Start meldete das Log `Migration needed. Performing migration...` und die Migration `add ai prompt overrides`, nach rund 10 Sekunden antwortete die API mit `"version":"v3.30.0"` und `"allowSignup":false`, der Container stand auf `healthy`. Das Marker-Rezept, das geänderte Passwort und die Mealie-Sicherung aus 3.29.0 waren vorhanden, das alte Standardpasswort wurde mit `401` abgewiesen, und das Offline-Archiv des Ordners `data` ließ sich unter 3.30.0 vollständig zurückspielen.

Wichtig für Installationen mit KI-Funktionen: 3.30.0 entfernt laut Release Notes die Variable `OPENAI_CUSTOM_PROMPT_DIR`. Eigene Prompts aus diesem Ordner übernimmt Mealie beim ersten Start automatisch in die neue Prompt-Verwaltung in der Oberfläche; danach können Sie die Variable aus der Konfiguration streichen. Neu sind außerdem Zeitangaben je Zubereitungsschritt, Essenspläne für eine ganze Woche statt eines festen Tages und die Einstellung `OIDC_VERIFY_X509_STRICT`. Mealie lauscht jetzt standardmäßig auf IPv4 und IPv6, und ein unbekannter Wert in `DB_ENGINE` führt zu einem Fehler statt stillschweigend zu SQLite.

### Update von 3.30.0 auf 3.31.0

Das Update von 3.30.0 auf 3.31.0 lief mit derselben Compose-Datei nach dem Ablauf oben. Das Log meldete die Migrationen `drop recipe cook_time`, `index recipes by group and created_at` und `index unindexed foreign keys`, danach antwortete die API mit `"version":"v3.31.0"` und `"allowSignup":false`, der Container stand auf healthy. Marker-Rezept und geändertes Passwort waren vorhanden, das alte Standardpasswort wurde mit 401 abgewiesen. Eine unter 3.31.0 erstellte Mealie-Sicherung und das Offline-Archiv des Ordners `data` ließen sich vollständig zurückspielen.

3.31.0 schließt laut Release Notes mehrere Sicherheitslücken, unter anderem beim Datenzugriff zwischen Gruppen und Haushalten und bei Links zum Zurücksetzen des Passworts; die Entwickler empfehlen das Update allen. Ebenfalls laut Release Notes sind Anfragen jetzt auf `MAX_UPLOAD_SIZE_MB` begrenzt (Standard 1024), größere Uploads wie umfangreiche Sicherungen enden mit 413, bis Sie den Wert anheben. Links zum Zurücksetzen des Passworts verfallen nach `PASSWORD_RESET_TOKEN_TIME` Stunden (Standard 1). Die Rezept-API liefert laut Release Notes keine Kochzeit mehr in `cookTime`: Im Test stand der vorher gesetzte Wert nach dem Update in `performTime`. Dieses Feld zeigt die Oberfläche laut Release Notes als Kochzeit („Cook Time“) an.

Grundlagen zum Betrieb finden Sie in [Docker Compose unter Linux: Grundlage für Selfhosting](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage), [Docker Compose absichern: Secrets, Healthchecks, Non-Root](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root) und [Linux-Server absichern mit UFW und Fail2ban](https://s-edv.com/anleitungen/linux-server-absichern-ufw-fail2ban).

## Troubleshooting

| Fehlerbild | Ursache und Lösung |
| --- | --- |
| `failed to resolve reference "ghcr.io/mealie-recipes/mealie:3.31.0": not found` | Tag ohne `v`. Richtig ist `v3.31.0`. |
| `Bind for 127.0.0.1:9925 failed: port is already allocated` | Port belegt. Anderen Host-Port wählen. Nach dem Freimachen zeigte `docker port mealie` bei einem einfachen `up -d` nichts an, erst `docker compose up -d --force-recreate` setzte die Bindung. |
| `PermissionError: [Errno 13] Permission denied: '/app/data/groups'` | Container wurde direkt als fremder Benutzer gestartet. `PUID` und `PGID` nutzen, kein `user:` setzen. |
| `403 User Registration is Disabled` | Gewolltes Verhalten bei `ALLOW_SIGNUP: "false"`. |
| `400 BAD_RECIPE_DATA` beim URL-Import | Seite enthält keine lesbaren Rezeptdaten oder blockiert den Abruf. Rezept manuell anlegen. |
| `401 Could not validate credentials` | Token nach Passwortänderung ungültig. Neu anmelden. |
| Seiteneinstellungen melden eine unerwartete Basis-URL | `BASE_URL` prüfen und anpassen, Container neu erstellen. |

## Häufige Fragen

### SQLite oder PostgreSQL?

Für eine Familie, eine Kantine oder einen kleinen Betrieb genügt SQLite. PostgreSQL lohnt bei vielen gleichzeitigen Benutzern, bei Datenhaltung auf einem NAS oder für Funktionen wie unscharfe Suche, die laut Dokumentation nur dort aktiv sind. Zwischen beiden wechseln Sie über Backup und Restore.

### Muss ich :latest vermeiden?

Das Tag `latest` existiert, die Entwickler empfehlen aber ausdrücklich eine feste Version, damit Updates bewusst passieren.

### Reicht das Mealie-Backup allein?

Nein. Es liegt auf demselben Datenträger wie die Daten. Kopieren Sie Zip oder Archiv an einen zweiten Ort.

### Wie viele Personen darf ich einladen?

Die Dokumentation nennt für SQLite 1 bis 20 Benutzer als passenden Bereich. Eigene Lastmessungen gibt es hier nicht.

## Fazit

Mealie läuft mit einer kurzen Compose-Datei und einem Datenordner. Wichtig sind drei Handgriffe direkt nach dem Start: Standardkonto ändern, Registrierung geschlossen lassen, TLS davorsetzen. Die Sicherung ist unkompliziert, solange Sie sie wirklich auf ein zweites System kopieren und die Wiederherstellung einmal geübt haben.

## Weiterführende Anleitungen und Quellen

- [Caddy als Reverse Proxy mit automatischem HTTPS](https://s-edv.com/anleitungen/caddy-reverse-proxy-automatisches-https-anleitung)
- [Docker-Container-Updates mit Diun und WUD](https://s-edv.com/anleitungen/docker-container-updates-watchtower-nachfolger-diun-wud)
- [Kopia mit Docker als Backup-Werkzeug](https://s-edv.com/anleitungen/kopia-docker-backup-tool)
- [Mealie-Dokumentation: Installation mit SQLite](https://docs.mealie.io/documentation/getting-started/installation/sqlite/)
- [Mealie-Dokumentation: Backend-Konfiguration](https://docs.mealie.io/documentation/getting-started/installation/backend-config/)
- [Mealie-Dokumentation: Backups und Restore](https://docs.mealie.io/documentation/getting-started/usage/backups-and-restoring/)
- [Mealie auf GitHub, Release v3.31.0](https://github.com/mealie-recipes/mealie/releases/tag/v3.31.0)

## Eckdaten

| Merkmal | Wert |
| --- | --- |
| Image | `ghcr.io/mealie-recipes/mealie:v3.31.0` |
| Port | Container 9000, Host im Beispiel 127.0.0.1:9925 |
| Daten | `./data` nach `/app/data` (Datenbank, Bilder, Backups) |
| Wichtige Variablen | `ALLOW_SIGNUP`, `PUID`, `PGID`, `TZ`, `BASE_URL` |
| Architekturen | linux/amd64, linux/arm64 |
| Lizenz | AGPL-3.0 |
