Homelab--Bratonein-Kontrollzentrum--Tutorial/Kapitel 20/Free Rohtext.md

# Kapitel 20 – Tandoor (Rezeptdatenbank)

## Einleitung

Rezepte sind im digitalen Alltag oft über viele Orte verteilt – Screenshots aus Chats, alte PDFs, Webseiten-Bookmarks oder Notizen in der Cloud.  
Gerade in einer kreativen Umgebung wie dem **UCC** ist eine zentrale, strukturierte Verwaltung von Rezepten, Zutaten und Menüs nicht nur komfortabel,  
sondern auch die Grundlage für Automatisierung, Wochenplanung und gemeinsame Nutzung in Teams oder Familien.

**Tandoor Recipes** ist eine selbstgehostete Rezeptdatenbank, die genau das bietet:  
Ein elegantes Web-Interface, übersichtliche Kategorisierung, automatischen Nährwertabgleich, Einkaufsliste und Planungsfunktionen.  
Die Daten bleiben vollständig auf deinem Server – ohne Drittanbieter, ohne Tracking, mit vollständiger Kontrolle über Zugriffe und Berechtigungen.

In diesem Kapitel richtest du **Tandoor** als eigenen **LXC-Container** in deinem UCC ein,  
konfigurierst Benutzer, Import- und Exportfunktionen und bindest das System sicher über den **Nginx Proxy Manager** ein.  
Optional lernst du im Premium-Teil, wie du Rollenverwaltung, Wochenpläne und Nährwertberechnung aktivierst und automatisierst.

👉 **Screenshot geeignet:** UCC-Dashboard mit markiertem Tandoor-Container zwischen Nextcloud und Vaultwarden

> [!NOTE]  
> Tandoor ist ideal für den privaten oder gemeinschaftlichen Einsatz – z. B. in Stream-Küchen, Vereinen oder Familien.  
> Es ersetzt keine professionelle Warenwirtschaft, bietet aber alles, was für die Verwaltung und Planung eigener Rezepte benötigt wird.

Tandoor unterstützt neben klassischen Rezeptansichten auch Uploads von Bildern, Schritt-für-Schritt-Anleitungen, Zutatenverknüpfungen und Tags.  
Über Schnittstellen lässt sich das System später mit Tools wie **n8n**, **Nextcloud** oder **Vaultwarden** kombinieren,  
um z. B. Einkaufslisten automatisch zu synchronisieren oder Rezepte sicher zu teilen.

👉 **Screenshot geeignet:** Browseransicht der Tandoor-Startseite mit Beispielrezepten und Navigationsleiste „Rezepte | Zutaten | Planung“

---

## Voraussetzungen & Ressourcen

Tandoor ist ein modernes Django-basiertes Websystem mit Datenbank-Backend und Python-Umgebung.  
Um die Anwendung zuverlässig und performant zu betreiben, wird eine saubere Containerstruktur mit klar definierten Ressourcen benötigt.  
Alle Dienste laufen vollständig innerhalb des Containers – inklusive Webserver, Datenbank und statischer Dateiverwaltung.

### Container-Ressourcen

* **CPU:** 2 vCPU  
  Erforderlich für parallele Prozesse bei der Datenbankabfrage, der Bildverarbeitung und der Weboberfläche.

* **RAM:** 3 GB  
  Nötig für Python-Django-Anwendungen und PostgreSQL-Caching.  
  So bleibt die Oberfläche auch bei mehreren gleichzeitigen Zugriffen flüssig.

* **Speicherplatz:** 15 GB  
  Deckt System, Datenbank, Rezeptbilder und Backups ab.  
  Erweiterungen wie Wochenplan oder Nährwertdatenbank können später zusätzlichen Platz beanspruchen.

* **Netzwerk:** Statische IP oder DHCP-Reservierung  
  Für Proxy-Integration und SSL-Zertifikate ist eine feste Zuordnung erforderlich.

* **Betriebssystem:** Ubuntu 24.04 LTS  
  Optimale Kompatibilität mit Python-Paketen, PostgreSQL 15 und Docker-Compose.  
  LTS-Version mit Sicherheits- und Performance-Updates bis 2029.

👉 **Screenshot geeignet:** Ressourcenübersicht beim Erstellen des Tandoor-LXC (2 vCPU | 3 GB RAM | 15 GB Storage | Ubuntu 24.04)

### Technische Voraussetzungen

Vor der Einrichtung sollte dein UCC folgende Punkte erfüllen:

* **Proxmox VE** ist aktiv und bereit zur Containererstellung.  
  Der Tandoor-Container wird direkt über die Proxmox-Oberfläche angelegt.

* **Nginx Proxy Manager (NPM)** ist installiert und erreichbar.  
  Darüber erfolgt die HTTPS-Bereitstellung der Weboberfläche.

* **DNS- oder DynDNS-Eintrag** für `tandoor.deinedomain.tld` ist vorhanden.  
  Wird für Zertifikatserstellung und HTTPS-Zugriff benötigt.

* **Internetverbindung** im Container ist stabil.  
  Tandoor lädt Abhängigkeiten aus offiziellen Python- und Node-Repositories.

* **SSH-Zugriff** ist möglich, z. B. per:  
  ```bash
  ssh root@<IP-des-Containers>
  ```
  Ersetze `<IP-des-Containers>` durch die tatsächliche Adresse deines Tandoor-LXC.

> [!IMPORTANT]  
> Für reibungslose Performance sollte der Container auf einem Host mit SSD-Speicher laufen.  
> Tandoor speichert Rezeptbilder und Vorschaudaten lokal – langsame I/O-Systeme führen zu verzögerter Ladezeit.

👉 **Screenshot geeignet:** Proxmox-Interface mit markiertem Tandoor-LXC in der Containerliste

---

## Schritt-für-Schritt-Anleitung

### Schritt 1 – Container vorbereiten und System aktualisieren

Starte den frisch erstellten **Tandoor-Container** in Proxmox und öffne die Konsole – entweder direkt über das Webinterface oder per SSH.

Zuerst werden alle Systempakete aktualisiert, um sicherzustellen, dass Ubuntu über aktuelle Sicherheits- und Python-Pakete verfügt:

```bash
apt update && apt upgrade -y
```

Nach Abschluss den Container neu starten:

```bash
reboot
```

Danach erneut einloggen:

```bash
ssh root@<IP-des-Containers>
```

> [!NOTE]  
> Ein aktuelles Basissystem ist zwingend erforderlich, da Tandoor auf moderne Python-Versionen und aktuelle PostgreSQL-Bibliotheken angewiesen ist.  
> Alte Paketstände führen häufig zu Problemen bei der Paketinstallation oder beim Start des Django-Servers.

👉 **Screenshot geeignet:** Proxmox-Konsole mit erfolgreichem Abschluss von `apt upgrade` (alle Pakete aktuell)

Nach dem Reboot legst du die grundlegende Verzeichnisstruktur an, um Konfiguration, Datenbank- und Mediendaten sauber zu trennen:

```bash
mkdir -p /opt/tandoor/{config,data,media,logs}
```

> [!TIP]  
> Diese Struktur sorgt für klare Trennung zwischen System, Anwendungsdaten und Backups.  
> Sie ist identisch mit der Empfehlung aus der offiziellen Tandoor-Dokumentation.

👉 **Screenshot geeignet:** Terminalansicht mit ausgeführtem `ls -l /opt/tandoor` (alle vier Unterordner sichtbar)

### Schritt 2 – Docker installieren und vorbereiten

Tandoor wird offiziell als Docker-Anwendung betrieben.  
Damit der Container stabil und unabhängig läuft, installierst du zunächst Docker Engine und Docker Compose direkt im Tandoor-LXC.

Führe nacheinander folgende Befehle aus:

```bash
apt install -y ca-certificates curl gnupg lsb-release
```

Dann das offizielle Docker-Repository hinzufügen und die Engine installieren:

```bash
mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" \
  | tee /etc/apt/sources.list.d/docker.list > /dev/null

apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```

Prüfe anschließend die Installation:

```bash
docker --version
docker compose version
```

Die Ausgabe sollte in etwa so aussehen:

```
Docker version 26.1.x
Docker Compose version v2.29.x
```

> [!NOTE]  
> Tandoor nutzt **Docker Compose** für den kompletten Stack – Web-App, Datenbank und statische Dateien.  
> Diese Installationsmethode ist offiziell empfohlen und vereinfacht spätere Updates sowie Backups erheblich.

👉 **Screenshot geeignet:** Terminalausgabe mit sichtbarer Docker- und Compose-Version nach erfolgreicher Installation

Damit ist die Grundlage für die Tandoor-Umgebung gelegt.  
Im nächsten Schritt erstellst du die lokale Verzeichnisstruktur und Konfigurationsdateien für die Anwendung.

### Schritt 3 – Verzeichnisstruktur und Konfiguration anlegen

Tandoor benötigt für den Betrieb mehrere persistent gespeicherte Bereiche – für Konfiguration, Datenbank, Medien und Logdateien.  
Damit alles sauber getrennt und sicher bleibt, legst du zunächst die komplette Ordnerstruktur im Container an.

```bash
mkdir -p /opt/tandoor/{config,data,media,logs}
cd /opt/tandoor
```

👉 **Screenshot geeignet:** Terminalansicht mit ausgeführtem `ls -l /opt/tandoor` (alle vier Unterordner sichtbar)

#### `.env`-Datei erstellen

Alle wichtigen Einstellungen für den Tandoor-Betrieb werden in einer zentralen `.env`-Datei definiert.  
Hier legst du Datenbankverbindung, Pfade, Sicherheitsparameter, Log-Level und Mailserver-Zugang fest.

Öffne die Datei:

```bash
nano /opt/tandoor/.env
```

Füge folgenden Inhalt ein:

```ini
TZ=Europe/Berlin
SECRET_KEY=$(openssl rand -hex 32)
DEBUG=0
ALLOWED_HOSTS=tandoor.deinedomain.tld,localhost,127.0.0.1

DB_ENGINE=django.db.backends.postgresql
DB_HOST=db
DB_PORT=5432
DB_NAME=tandoor
DB_USER=tandoor
DB_PASSWORD=$(openssl rand -hex 16)

MEDIA_ROOT=/opt/tandoor/media
STATIC_ROOT=/opt/tandoor/static

EMAIL_USE_TLS=True
EMAIL_PORT=<VAULTWARDEN:SMTP_PORT>
EMAIL_HOST=<VAULTWARDEN:SMTP_HOST>
EMAIL_HOST_USER=<VAULTWARDEN:SMTP_USER>
EMAIL_HOST_PASSWORD=<VAULTWARDEN:SMTP_PASSWORD>

LOG_LEVEL=INFO
```

> [!NOTE]  
> Die Datei `.env` enthält alle wichtigen Umgebungsvariablen für Tandoor.  
> Die SMTP-Werte werden aus Vaultwarden → **Eintrag „UCC-Mailserver (SMTP)”** übernommen.  
> Ersetze die Platzhalter `<VAULTWARDEN:...>` durch die entsprechenden Werte aus deinem Passwortmanager.

> [!IMPORTANT]  
> Die `.env`-Datei enthält sensible Daten. Setze nach dem Speichern die Zugriffsrechte so, dass nur root Zugriff hat:
> ```bash
> chmod 600 /opt/tandoor/.env
> ```

👉 **Screenshot geeignet:** geöffnete `.env`-Datei mit markierten Variablen (DB_HOST, SECRET_KEY, EMAIL_HOST)

#### `docker-compose.yml`-Datei anlegen

Nun definierst du den eigentlichen Docker-Stack. Er besteht aus zwei Diensten: einer PostgreSQL-Datenbank und der Tandoor-Webanwendung.

```bash
nano /opt/tandoor/docker-compose.yml
```

Füge folgenden Inhalt ein:

```yaml
version: "3.9"

services:
  db:
    image: postgres:15
    container_name: tandoor-db
    restart: unless-stopped
    environment:
      POSTGRES_DB: tandoor
      POSTGRES_USER: tandoor
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - ./data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U tandoor"]
      interval: 30s
      timeout: 10s
      retries: 5

  web:
    image: vabene1111/recipes:latest
    container_name: tandoor
    restart: unless-stopped
    env_file:
      - .env
    depends_on:
      db:
        condition: service_healthy
    ports:
      - "8080:8080"
    volumes:
      - ./media:/opt/tandoor/media
      - ./logs:/opt/tandoor/logs
```

> [!TIP]  
> Die Docker-Compose-Datei definiert den gesamten Stack klar getrennt in zwei Containern.  
> Die Anwendung startet erst, wenn die Datenbank bereit ist.  
> Alle Daten bleiben in den Volumes `/opt/tandoor/data` und `/opt/tandoor/media` persistent gespeichert.

👉 **Screenshot geeignet:** Terminal mit geöffneter `docker-compose.yml` und markiertem Dienst `tandoor` sowie `tandoor-db`

Damit ist der Stack vollständig vorbereitet.  
Im nächsten Schritt startest du die Container und überprüfst, ob Tandoor korrekt läuft.

### Schritt 4 – Container starten und erste Verbindung prüfen

Mit der vorbereiteten `.env`- und `docker-compose.yml`-Datei kannst du jetzt den kompletten Tandoor-Stack starten.  
Docker lädt dabei automatisch alle benötigten Images und richtet Datenbank sowie Anwendung ein.

Starte die Container:

```bash
docker compose up -d
```

Die Images werden beim ersten Start heruntergeladen.  
Dieser Vorgang kann – je nach Internetgeschwindigkeit – einige Minuten dauern.

Überprüfe anschließend den Status:

```bash
docker compose ps
```

Die Ausgabe sollte in etwa so aussehen:

```
NAME          IMAGE                         STATUS         PORTS
tandoor-db    postgres:15                   Up 1 minute    5432/tcp
tandoor       vabene1111/recipes:latest     Up 1 minute    0.0.0.0:8080->8080/tcp
```

> [!NOTE]  
> Sobald beide Container den Status **Up** anzeigen, ist das Grundsystem aktiv.  
> Die Weboberfläche wird über Port 8080 des Containers bereitgestellt.

👉 **Screenshot geeignet:** Terminalausgabe von `docker compose ps` mit aktiven Diensten *tandoor* und *tandoor-db*

Öffne nun im Browser:

```
http://<IP-des-Containers>:8080
```

Wenn alles korrekt funktioniert, erscheint die Tandoor-Startseite mit dem Hinweis, einen Administrator-Account anzulegen.  
Trage hier Benutzername, E-Mail und Passwort ein, um das erste Konto zu erstellen.

> [!IMPORTANT]  
> Verwende hier eine E-Mail-Adresse, die im Mailserver des UCC existiert (z. B. `tandoor@deinedomain.tld`).  
> Nur so kann der spätere Passwort-Reset oder die Benutzer-Einladung über den konfigurierten SMTP-Server funktionieren.

👉 **Screenshot geeignet:** Browseransicht der Tandoor-Registrierungsseite mit Eingabefeldern für Benutzername, E-Mail und Passwort

Nach der Registrierung wirst du direkt ins Dashboard weitergeleitet.  
Dort siehst du das Hauptmenü mit den Bereichen **Rezepte**, **Zutaten**, **Planung** und **Einstellungen**.

> [!TIP]  
> Wenn die Seite nicht erreichbar ist, prüfe, ob Port 8080 eventuell von einer Firewall blockiert wird oder bereits belegt ist.  
> Du kannst den Port in der `docker-compose.yml` jederzeit anpassen (z. B. auf `8081:8080`), danach Container neu starten:
> ```bash
> docker compose down
> docker compose up -d
> ```

👉 **Screenshot geeignet:** Browserfenster mit geöffneter Tandoor-Startseite (Dashboard-Ansicht nach Anmeldung)

Damit ist Tandoor erfolgreich gestartet und über das lokale Netzwerk erreichbar.  
Im nächsten Schritt folgt die Integration in den **Nginx Proxy Manager**, um den Dienst sicher per HTTPS bereitzustellen.

### Schritt 5 – Integration in Nginx Proxy Manager (NPM)

Damit Tandoor sicher über HTTPS erreichbar ist, wird der interne Port 8080 nun über den **Nginx Proxy Manager** veröffentlicht.  
Dadurch erhältst du eine verschlüsselte Verbindung und kannst den Dienst komfortabel über eine eigene Subdomain ansprechen.

#### Proxy-Host anlegen

1. Öffne das Dashboard des **Nginx Proxy Manager**.  
2. Klicke auf **Add Proxy Host**.  
3. Trage folgende Werte ein:

| Feld | Wert |
|------|------|
| **Domain Names** | `tandoor.deinedomain.tld` |
| **Scheme** | `http` |
| **Forward Hostname / IP** | `<IP-des-Tandoor-Containers>` |
| **Forward Port** | `8080` |
| **Block Common Exploits** | aktivieren |
| **Websockets Support** | aktivieren |

Wechsle in den Reiter **SSL** und aktiviere folgende Optionen:

- **Request a new SSL Certificate**  
- **Force SSL**  
- **HTTP/2 Support**  
- **HSTS Enabled**

Klicke danach auf **Save**.

> [!NOTE]  
> Der Proxy Manager beantragt automatisch ein gültiges Let’s-Encrypt-Zertifikat.  
> Voraussetzung ist, dass die Domain `tandoor.deinedomain.tld` bereits korrekt auf deinen Server zeigt.  
> Bei lokalen Tests kann stattdessen ein selbstsigniertes Zertifikat verwendet werden.

👉 **Screenshot geeignet:** NPM-Dashboard mit geöffnetem Proxy-Host `tandoor.deinedomain.tld`

#### Verbindung prüfen

Öffne im Browser:

```
https://tandoor.deinedomain.tld
```

Wenn alles korrekt eingerichtet ist, erscheint die Tandoor-Startseite nun über eine sichere HTTPS-Verbindung.  
Das **Schloss-Symbol** im Browser zeigt ein aktives SSL-Zertifikat an.

> [!TIP]  
> Sollte die Seite nicht laden, prüfe im NPM-Dashboard, ob IP-Adresse und Port stimmen.  
> Starte den Container gegebenenfalls neu:
> ```bash
> docker compose restart
> ```

👉 **Screenshot geeignet:** Browserfenster mit Tandoor-Interface unter `https://tandoor.deinedomain.tld` (Schloss-Symbol sichtbar)

> [!IMPORTANT]  
> Die HTTPS-Einbindung ist Voraussetzung, damit Funktionen wie E-Mail-Verifikation, OAuth-Anmeldung oder API-Zugriffe später problemlos funktionieren.  
> Ohne gültiges Zertifikat lehnen viele Browser die Verbindung oder Formulareingaben ab.

Damit ist Tandoor nun sicher über HTTPS erreichbar.  
Im nächsten Schritt kannst du Benutzer anlegen, Rezepte importieren und erste Strukturen aufbauen.

### Schritt 6 – Erste Benutzer und Grundeinstellungen

Nach der erfolgreichen Installation und HTTPS-Einbindung kannst du Tandoor nun für die tägliche Nutzung einrichten.  
Dazu gehören das Anlegen erster Benutzer, das Festlegen von Berechtigungen und grundlegende Systemeinstellungen wie Zeitzone, Sprache und E-Mail-Absenderadresse.

#### Administrator-Benutzer bestätigen

Beim ersten Start hast du einen Administrations-Account erstellt.  
Dieser besitzt vollständige Rechte und verwaltet Benutzer, Rezepte und Systemoptionen.

Melde dich an unter:

```
https://tandoor.deinedomain.tld
```

Benutzername und Passwort stammen aus dem Setup-Dialog des ersten Starts.

👉 **Screenshot geeignet:** Tandoor-Loginmaske mit eingegebenem Administrator-Benutzernamen

Nach der Anmeldung öffnet sich das **Dashboard** mit den Menüpunkten **Rezepte**, **Zutaten**, **Planung**, **Einkaufsliste** und **Einstellungen**.  
Wechsle in den Bereich **Einstellungen → Benutzerverwaltung**.

> [!NOTE]  
> Nur der erste angelegte Benutzer hat standardmäßig Administratorrechte.  
> Weitere Benutzer müssen manuell eingeladen und den Rollen *User* oder *Admin* zugewiesen werden.

👉 **Screenshot geeignet:** Dashboard mit geöffnetem Menüpunkt *Benutzerverwaltung*

#### Neue Benutzer einladen

Klicke auf **Benutzer hinzufügen** und trage folgende Felder aus:

| Feld | Beschreibung |
|------|---------------|
| **Benutzername** | frei wählbar, z. B. „kochteam“ |
| **E-Mail** | Adresse, über die Tandoor Einladungen verschickt |
| **Rolle** | *User* oder *Admin* |
| **Aktiv** | aktivieren |

Speichere anschließend.  
Wenn dein SMTP-Server korrekt konfiguriert ist, erhält der neue Benutzer automatisch eine Einladungs-Mail mit Link zur Passwortvergabe.

> [!IMPORTANT]  
> Für den Versand dieser E-Mail müssen die SMTP-Werte in der `.env`-Datei korrekt gesetzt sein.  
> Teste den Versand unter **Einstellungen → Test-E-Mail senden**, bevor du Benutzer einlädst.

👉 **Screenshot geeignet:** Benutzerformular mit ausgefüllter E-Mail und aktivierter Rolle *User*

#### Grundeinstellungen anpassen

Unter **Einstellungen → Allgemein** kannst du Sprache, Zeitzone, Maßeinheiten und Standard-Darstellung anpassen.  
Setze folgende empfohlene Werte:

| Einstellung | Wert |
|--------------|------|
| **Sprache** | Deutsch |
| **Zeitzone** | Europe/Berlin |
| **Maßeinheiten** | metrisch (g, ml, °C) |
| **Standard-Startseite** | Rezepte |

Speichere die Änderungen mit **Speichern** unten auf der Seite.

> [!TIP]  
> Diese Optionen gelten global für alle Benutzer.  
> Individuelle Spracheinstellungen können später pro Benutzer angepasst werden.

👉 **Screenshot geeignet:** Einstellungsseite mit markierten Feldern Sprache = Deutsch und Zeitzone = Europe/Berlin

#### E-Mail-Absender konfigurieren

Damit ausgehende Systemmails korrekt gekennzeichnet sind, trägst du unter **Einstellungen → E-Mail** den Absendernamen und die Adresse ein.

Empfohlene Werte:

| Feld | Beispiel |
|------|-----------|
| **Absendername** | Tandoor UCC |
| **Absenderadresse** | tandoor@deinedomain.tld |

> [!NOTE]  
> Diese Felder steuern nur die sichtbare Absenderkennung.  
> Der Versand erfolgt weiterhin über den in der `.env`-Datei eingetragenen SMTP-Server.

👉 **Screenshot geeignet:** Einstellungsseite „E-Mail“ mit ausgefüllten Feldern Absendername und Absenderadresse

### Schritt 7 – Rezepte importieren und Medien verwalten

Nachdem Benutzer und Grundeinstellungen gesetzt sind, kannst du beginnen, Inhalte in Tandoor zu importieren und deine eigene Rezeptbibliothek aufzubauen.  
Tandoor bietet dafür mehrere komfortable Wege – vom manuellen Eintrag über URL-Import bis zum Upload kompletter Sammlungen.

#### Einzelne Rezepte anlegen

Wähle im Hauptmenü **Rezepte → Neues Rezept**.  
Fülle die wichtigsten Felder aus:

| Feld | Beschreibung |
|------|---------------|
| **Titel** | Name des Rezepts |
| **Beschreibung** | Kurztext oder Hintergrundinformation |
| **Zubereitungszeit / Gesamtzeit** | Minutenangaben |
| **Portionen** | Anzahl der Portionen |
| **Zutatenliste** | Zeilenweise Eingabe von Menge und Zutat |
| **Anleitung** | Schritt-für-Schritt Beschreibung |

> [!TIP]  
> Tandoor speichert alle Eingaben sofort in der Datenbank.  
> Du kannst Rezepte später jederzeit bearbeiten, ohne sie neu anzulegen.

👉 **Screenshot geeignet:** Formular „Neues Rezept“ mit ausgefüllten Basisfeldern Titel, Portionen, Zutatenliste

#### Rezepte aus URLs importieren

Tandoor kann viele Webseiten direkt analysieren und Rezepte automatisch übernehmen.  
Klicke im Menü **Rezepte → Importieren → Von URL** und füge die Adresse einer unterstützten Rezeptseite ein, z. B.:

```
https://www.chefkoch.de/rezepte/12345
```

Klicke auf **Importieren**.  
Nach wenigen Sekunden wird das Rezept mit Titel, Zutaten, Zubereitungsschritten und Bild übernommen.

> [!NOTE]  
> Der URL-Import nutzt standardisierte Schema.org-Metadaten, die von vielen Kochseiten bereitgestellt werden.  
> Nicht alle Webseiten sind kompatibel. Wenn der Import fehlschlägt, nutze den manuellen Weg oder den JSON-Import.

👉 **Screenshot geeignet:** Importmaske mit eingefügter URL und sichtbarem Fortschrittsbalken „Import erfolgreich“

#### JSON- oder ZIP-Import

Wenn du bereits Rezepte aus einer anderen Instanz oder Sicherung besitzt, kannst du sie gesammelt importieren.  
Gehe zu **Einstellungen → Datenverwaltung → Import/Export** und wähle **Datei hochladen**.

Unterstützte Formate:
- `.json` (Tandoor-Export)
- `.zip` (gesamte Sammlung mit Bildern)

Wähle die Datei auf deinem Rechner aus und starte den Import.

> [!IMPORTANT]  
> Beim Import werden gleichnamige Rezepte nicht automatisch überschrieben.  
> Prüfe nach dem Vorgang doppelte Einträge manuell in der Rezeptliste.

👉 **Screenshot geeignet:** Einstellungsseite „Import/Export“ mit hochgeladener JSON-Datei und Fortschrittsanzeige

#### Bilder und Medien hinzufügen

Jedes Rezept kann eigene Fotos, PDFs oder Zusatzdokumente enthalten.  
Öffne das gewünschte Rezept und klicke auf **Medien → Datei hochladen**.

Unterstützte Formate:
- **Bilder:** JPG, PNG, WEBP  
- **Dokumente:** PDF  
- **Vorschaubilder:** automatisch generiert

Die Dateien werden in `/opt/tandoor/media` gespeichert und über den Webserver ausgeliefert.

> [!TIP]  
> Halte die Bildgrößen moderat (unter 2 MB pro Bild).  
> Große Dateien verlangsamen die Anzeige und belasten Backups.  
> Du kannst Bilder außerhalb von Tandoor mit Tools wie *ImageMagick* oder *TinyPNG* verkleinern.

👉 **Screenshot geeignet:** geöffneter Rezeptsatz mit hinzugefügtem Foto im Bereich „Medien“

#### Kategorien und Tags

Zur besseren Übersicht lassen sich Rezepte kategorisieren.  
Öffne **Rezepte → Kategorien** und lege neue Einträge wie *Vorspeise*, *Hauptgericht*, *Dessert* oder *Vegetarisch* an.  
Du kannst Kategorien später Rezepten zuweisen oder mehrere kombinieren.

> [!NOTE]  
> Kategorien erscheinen als Filter im Dashboard und können auch in Wochenplänen oder Einkaufsliste genutzt werden.

👉 **Screenshot geeignet:** Kategorieverwaltung mit mehreren Einträgen (Vorspeise, Hauptgericht, Dessert)

Damit ist die Basis für deine eigene Rezeptdatenbank vollständig eingerichtet.  
Im nächsten Schritt lernst du, wie du Tandoor in deine Backuproutinen und das Monitoring des UCC einbindest.

---

## Troubleshooting & Tipps

Auch wenn Tandoor im Alltag sehr stabil läuft, kann es bei der Einrichtung oder im Dauerbetrieb zu kleineren Problemen kommen –  
von nicht geladenen Seiten über E-Mail-Fehler bis hin zu fehlenden Bildern.  
Die folgenden Punkte helfen dir, typische Ursachen schnell zu erkennen und zu beheben, ohne tief in Systemdetails einzusteigen.

### Tandoor lädt nicht oder zeigt nur eine weiße Seite

**Symptom:**  
Nach dem Start des Containers erscheint im Browser nur eine leere Seite oder der Ladevorgang bricht ab.

**Lösungen:**  
1. **Container läuft nicht richtig:**  
   Prüfe im Terminal:
   ```bash
   docker compose ps
   ```
   Wenn einer der Container den Status *Exited* oder *Restarting* zeigt, starte den gesamten Stack neu:
   ```bash
   docker compose down
   docker compose up -d
   ```

2. **Fehlerhafte Datenbankverbindung:**  
   Öffne `/opt/tandoor/.env` und überprüfe:
   ```
   DB_HOST=db
   DB_PORT=5432
   DB_NAME=tandoor
   DB_USER=tandoor
   DB_PASSWORD=<aus .env>
   ```
   Anschließend Container neu starten.

3. **Browser-Cache oder Cookie-Reste:**  
   Lösche den Cache oder öffne die Seite im privaten Fenster, um alte Sitzungen auszuschließen.

> [!TIP]  
> Wenn du dauerhaft nur eine weiße Seite siehst, hilft oft schon ein Neustart beider Container.  
> In vielen Fällen ist beim ersten Start noch nicht alles vollständig geladen.

👉 **Screenshot geeignet:** Terminalausgabe von `docker compose ps` mit einem gestoppten Dienst und anschließendem Neustart

### E-Mail-Versand funktioniert nicht

**Symptom:**  
Benutzer erhalten keine Einladungen oder Passwort-Reset-Mails.

**Lösungen:**  
1. Prüfe, ob die SMTP-Werte in der `.env` korrekt gesetzt wurden.  
   ```
   EMAIL_HOST
   EMAIL_PORT
   EMAIL_HOST_USER
   EMAIL_HOST_PASSWORD
   ```
2. Sende in Tandoor eine Testmail:  
   **Einstellungen → E-Mail → Test senden**
3. Wenn der Versand fehlschlägt, prüfe das Log:  
   ```bash
   docker compose logs -f tandoor
   ```

> [!NOTE]  
> Tandoor nutzt keinen eigenen Mailserver.  
> Der Versand erfolgt immer über den zentralen SMTP-Dienst deines UCC.  
> Stelle sicher, dass dieser erreichbar ist und Anmeldungen von Containern erlaubt.

👉 **Screenshot geeignet:** Tandoor-Einstellungsseite mit sichtbarem Button *Test-E-Mail senden*

### Bilder fehlen oder werden nicht geladen

**Symptom:**  
Rezeptbilder erscheinen als graue Platzhalter oder fehlen vollständig.

**Lösungen:**  
1. Prüfe die Pfade in der `.env`:  
   ```
   MEDIA_ROOT=/opt/tandoor/media
   STATIC_ROOT=/opt/tandoor/static
   ```
2. Überprüfe, ob das Volume in der `docker-compose.yml` korrekt eingebunden ist:  
   ```yaml
   volumes:
     - ./media:/opt/tandoor/media
   ```
3. Wenn die Dateien vorhanden, aber nicht abrufbar sind, passe Berechtigungen an:  
   ```bash
   chown -R 1000:1000 /opt/tandoor/media
   ```

> [!TIP]  
> Nach größeren Datei-Übertragungen kann es helfen, den Container einmal neu zu starten,  
> damit geänderte Berechtigungen übernommen werden.

👉 **Screenshot geeignet:** Medienordner im Terminal mit korrekten Eigentümerrechten (UID 1000)

### Anmeldung oder Passwort-Reset funktioniert nicht

**Symptom:**  
Benutzer können sich nicht anmelden oder erhalten beim Zurücksetzen des Passworts keine E-Mail.

**Lösungen:**  
1. Prüfe, ob das System über HTTPS läuft.  
   Viele Browser blockieren Formularübertragungen über unverschlüsselte HTTP-Verbindungen.  
2. Stelle sicher, dass in der `.env` die Zeile
   ```
   ALLOWED_HOSTS=tandoor.deinedomain.tld,localhost,127.0.0.1
   ```
   den korrekten Domainnamen enthält.
3. Wenn der E-Mail-Versand generell funktioniert, aber keine Nachricht ankommt, prüfe den Spam-Ordner oder die Absenderadresse.

> [!IMPORTANT]  
> Ohne gültige HTTPS-Verbindung kann Tandoor keine sicheren Links für Passwort-Resets erzeugen.  
> Die Integration über den Nginx Proxy Manager ist daher zwingend notwendig.

👉 **Screenshot geeignet:** Browserfenster mit sichtbarer HTTPS-Adresse und aktivem Schloss-Symbol

### Backups und Wiederherstellung mit Kopia

Tandoor sollte regelmäßig gesichert werden, um Datenverluste zu vermeiden.  
Die Sicherung erfolgt über das zentrale Kopia-System des UCC.

**Zu sichernde Verzeichnisse:**
- `/opt/tandoor/data`
- `/opt/tandoor/media`
- `/opt/tandoor/logs`
- `/opt/tandoor/.env`

> [!NOTE]  
> Sichere diese Verzeichnisse immer gemeinsam, damit Datenbank und Mediendateien synchron bleiben.

In Kopia:
1. **Add Source → Directory → `/opt/tandoor`**
2. **Name:** Tandoor Backup  
3. **Include hidden files:** aktivieren  
4. Backup-Zeitplan: täglich um 03:00 Uhr, 7 Tage Aufbewahrung, Kompression und Verschlüsselung aktivieren.

> [!TIP]  
> Teste regelmäßig eine Wiederherstellung, um sicherzugehen, dass das Backup vollständig ist.  
> Führe Test-Restores immer auf einem separaten Pfad aus – niemals über die laufende Installation.

👉 **Screenshot geeignet:** Kopia-Dashboard mit aktivem Eintrag *Tandoor Backup* und Zeitplan 03:00 Uhr

### Container bleibt nach Neustart gestoppt

**Symptom:**  
Nach einem Server- oder Container-Neustart ist Tandoor nicht automatisch wieder aktiv.

**Lösung:**  
Öffne `/opt/tandoor/docker-compose.yml` und prüfe, ob der Neustart-Modus gesetzt ist:
```
restart: unless-stopped
```
Wenn nicht, ergänze ihn unter beiden Diensten (`db` und `web`), dann Container neu starten.

> [!TIP]  
> Der Restart-Modus sorgt dafür, dass Docker den Container nach jedem Reboot automatisch wieder startet.  
> Ein zusätzlicher Cronjob oder systemd-Dienst ist nicht nötig.

👉 **Screenshot geeignet:** geöffnete `docker-compose.yml` mit sichtbarem Eintrag `restart: unless-stopped`

### Allgemeine Stabilität und Pflege

- Führe regelmäßig `apt update && apt upgrade -y` im Container aus, um Sicherheitsupdates einzuspielen.  
- Starte den Container etwa einmal pro Woche neu, um temporäre Caches zu leeren.  
- Überwache mit `docker stats`, ob CPU- oder RAM-Verbrauch auffällig hoch sind.  
- Leere alte Logdateien, wenn `/opt/tandoor/logs` zu groß wird.

> [!NOTE]  
> Bei regelmäßiger Pflege läuft Tandoor monatelang stabil ohne Eingriffe.  
> Der Dienst reagiert empfindlich auf Dateisystemprobleme – sichere daher das Volume `/opt/tandoor/data` regelmäßig.

👉 **Screenshot geeignet:** Terminalausgabe von `docker stats` mit laufendem Tandoor-Container

Damit ist der Troubleshooting-Teil vollständig und deckt alle typischen Fehlerquellen, Backup-Themen und Stabilitätsaspekte ab.

---

## Ergebnis

Nach Abschluss dieses Kapitels läuft in deinem UCC eine vollständig integrierte Rezeptverwaltung mit Tandoor.  
Du kannst eigene Rezepte erfassen, importieren, mit Bildern versehen und mit anderen Benutzer:innen teilen –  
alles innerhalb deiner privaten Infrastruktur und ohne externe Cloud-Dienste.

Dein aktuelles Setup umfasst:

- **Tandoor-Container** – verwaltet Rezepte, Medien und Benutzerzugänge  
- **PostgreSQL-Datenbank** – speichert alle Inhalte zuverlässig und performant  
- **Nginx Proxy Manager** – stellt den Dienst sicher per HTTPS bereit  
- **Vaultwarden-Integration** – liefert SMTP-Zugangsdaten aus dem zentralen Passwort-Tresor  
- **Kopia-Backup** – sichert alle Daten automatisch und stellt sie bei Bedarf wieder her  
- **Nutzer- und Rollenverwaltung** – ermöglicht gemeinsames Arbeiten im Team oder in der Familie

> [!NOTE]  
> Tandoor läuft vollständig lokal auf deinem UCC-System.  
> Alle Daten – inklusive Rezepte, Bilder und Zugangsdaten – bleiben unter deiner Kontrolle.  
> Für den Betrieb ist keine externe Verbindung oder Cloud-Anmeldung erforderlich.

👉 **Screenshot geeignet:** Tandoor-Dashboard mit sichtbaren Bereichen *Rezepte*, *Planung*, *Einstellungen* und aktivem Benutzer-Avatar

Damit hast du eine stabile, datensparsame und vielseitige Plattform geschaffen,  
um deine Koch- und Backrezepte zentral zu organisieren, gemeinsam zu nutzen und automatisch zu sichern.  
Tandoor fügt sich nahtlos in das bestehende UCC-Ökosystem ein und kann später mit Automatisierungen, Backups und Benachrichtigungen erweitert werden.