How to Install Tandoor Recipes on Debian 12

Tandoor Recipes on Debian 12 (Docker Compose + PostgreSQL + Nginx + SSL)

Tandoor Recipes is a free, open-source self-hosted recipe management system designed to help you store, organize, plan, and share recipes through an intuitive and elegant web interface. It features meal planning, shopping lists, nutritional data, tagging, and collaboration tools — all while ensuring your data stays private and under your control.

Running Tandoor Recipes on Debian 12 (Bookworm) provides a secure, stable, and production-ready foundation for your personal or shared recipe server. With Docker Compose, PostgreSQL, Nginx, and SSL encryption, Debian 12 offers a reliable, low-maintenance platform for hosting Tandoor Recipes in homes, professional kitchens, or small organizations.

Architecture Overview

Layer	Component	Role
OS	Debian 12 (Bookworm)	Stable, long-term supported Linux base for container deployments
Container Runtime	Docker Engine + Compose	Orchestrates Tandoor Recipes and its supporting services
Application	Tandoor Recipes (Django)	Core web application and backend logic
Database	PostgreSQL 15	Stores recipes, ingredients, user accounts, and metadata
Reverse Proxy	Nginx	Handles HTTPS termination, routing, and compression
TLS	Let’s Encrypt / PKI	Provides HTTPS security for dashboard and API access

Why Use Tandoor Recipes?

Centralized recipe management – organize all your recipes in one private place.
Web recipe importer – easily import from thousands of cooking websites.
Meal planning & shopping lists – plan meals and generate grocery lists instantly.
Nutritional tracking – analyze calories and ingredients automatically.
Multi-user support – share and collaborate with family or teammates.
Media uploads & tagging – attach photos and tags for quick search.
Privacy & ownership – full control of your data and backups.

Tandoor Recipes vs Other Recipe Platforms

Feature/Capability	Tandoor Recipes (Self-hosted)	Paprika (App)	Cookpad (Cloud)	AnyList (Cloud)
Hosting	Self-hosted / Docker	Mobile only	Cloud-based	Cloud-based
Cost	Free, open-source	Paid	Free/Paid	Subscription
Multi-user support	✅ Yes	❌ No	✅ Limited	✅ Limited
Nutrition data	✅ Yes	❌ No	❌ No	❌ No
Shopping lists	✅ Yes	✅ Yes	✅ Yes	✅ Yes
Privacy	100% local control	Cloud sync	Cloud only	Cloud only

Tandoor Recipes is the perfect open-source solution for home cooks, chefs, or teams who want a feature-rich and private recipe management system without relying on third-party cloud services.

Security & Best Practices

Deploy behind Nginx with HTTPS via Let’s Encrypt or custom SSL.
Store database credentials securely in .env or Docker secrets.
Keep PostgreSQL restricted to internal Docker networks.
Regularly update Debian, Docker, and Tandoor containers.
Use UFW or nftables to restrict access to ports 80 and 443 only.
Enable automatic SSL certificate renewal with Certbot or Traefik ACME.
Schedule automated PostgreSQL backups and test recovery regularly.
Ensure media and static volumes are properly mounted for persistence.
Use strong credentials for admin and database users.

Typical Use Cases

Personal recipe archives with advanced search and tagging.
Family cookbooks shared across multiple devices.
Professional kitchens managing internal recipe catalogs.
Meal prep planners generating dynamic grocery lists.
Nutrition tracking for dieticians or health-conscious users.

Deploying Tandoor Recipes on Debian 12 with Docker Compose and PostgreSQL provides a secure, private, and feature-rich self-hosted platform for organizing your recipes, planning meals, and managing ingredients — all while maintaining full control of your data.

Step 1: Set Up a Server Instance

To run Tandoor smoothly, you need a reliable server with enough resources. The easiest and most scalable way to deploy Tandoor is by using a Shape.Host Cloud VPS.

Click Create → Instance.

Choose the data center closest to your location for best performance.

Select a plan with at least 2 CPUs, 4 GB RAM, and 20 GB SSD.

Under Operating System, choose Debian 12 (Bookworm).

Click Create Instance.

After deployment, find your instance’s IP address under Resources.

Your Debian server is now ready for installation.

Step 2: Connect to Your Debian Instance

From Linux/macOS:

ssh root@your_server_ip

From Windows (PuTTY):

Open PuTTY
Enter your server IP
Login as root

Step 3: Install Docker & Requirements

Run the commands exactly as they appeared in your history:

Update the system

apt update

Install required certificates and tools

apt install ca-certificates curl gnupg

Create Docker keyring directory

install -m 0755 -d /etc/apt/keyrings

Add Docker GPG key

curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Fix permissions

chmod a+r /etc/apt/keyrings/docker.gpg

Add Docker repository

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

Update again

apt update

Install Docker Engine & Compose plugin

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

Check Docker Compose

docker compose version

Step 4: Deploy Tandoor Recipes

Create application directory

mkdir -p /opt/tandoor
cd /opt/tandoor

Download Tandoor environment template

wget https://raw.githubusercontent.com/vabene1111/recipes/develop/.env.template -O .env

Generate a secure Django SECRET_KEY

python3 -c "import secrets; print(secrets.token_urlsafe(50))"

Edit `.env` file

nano .env

Configure the following values:

SECRET_KEY: A long random string
POSTGRES_PASSWORD: Strong DB password
ALLOWED_HOSTS: Your domain
CSRF_TRUSTED_ORIGINS: https://your-domain.com

Example Snippet:

DEBUG=0
SECRET_KEY=GenerateAStrongRandomKeyHere12345

# Database
POSTGRES_HOST=db_recipes
POSTGRES_PORT=5432
POSTGRES_USER=djangouser
POSTGRES_PASSWORD=StrongDBPassword
POSTGRES_DB=djangodb

# Domain & SSL Settings
ALLOWED_HOSTS=recipes.example.com
CSRF_TRUSTED_ORIGINS=https://recipes.example.com

Create Docker Compose configuration

nano docker-compose.yml

Paste:

services:
  web_recipes:
    image: vabene1111/recipes:latest
    restart: always
    env_file:
      - ./.env
    volumes:
      - staticfiles:/opt/recipes/staticfiles
      - nginx_config:/opt/recipes/nginx/conf.d
      - ./mediafiles:/opt/recipes/mediafiles
    ports:
      - "8080:80"
    depends_on:
      - db_recipes

  db_recipes:
    image: postgres:15-alpine
    restart: always
    volumes:
      - ./postgresql:/var/lib/postgresql/data
    env_file:
      - ./.env

volumes:
  staticfiles:
  nginx_config:

Start Tandoor Recipe containers

docker compose up -d

Create superuser

docker compose exec web_recipes /opt/recipes/venv/bin/python3 manage.py createsuperuser

Step 5: Install & Configure Nginx

Install Nginx & Certbot

apt install nginx certbot python3-certbot-nginx

Create Nginx configuration

nano /etc/nginx/sites-available/tandoor

Paste:

server {
    listen 80;
    server_name recipes.example.com;

    client_max_body_size 100M; # For large recipe images

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Enable site

ln -s /etc/nginx/sites-available/tandoor /etc/nginx/sites-enabled/

Remove default site

rm /etc/nginx/sites-enabled/default

Test configuration

nginx -t

Reload Nginx

systemctl reload nginx

Step 6: Enable HTTPS with Certbot

certbot --nginx -d debian-tutorials.shape.host your-domain.com

This will automatically configure SSL and reload Nginx.

Step 7: Verify Installation

Open in your browser:

https://recipes.example.com

You should now see the Tandoor Recipes interface. Log in using the superuser account you created.

You have installed Tandoor Recipes on Debian 12, running on Docker with PostgreSQL, Nginx, and free SSL via Certbot. This production-ready stack ensures performance, security, and easy maintenance.

For the best performance and uptime, deploy your applications on Shape.Host Linux SSD VPS — a fast, scalable, and reliable platform ideal for self-hosted services like Tandoor.

Cloud Instances

Storage & Networking