Tandoor on VPS: installation, setup, and maintenance

Tandoor is a powerful self-hosted platform for convenient storage, organization, and management of your culinary recipes, and installing it on a VPS gives you full control over your data, ensures privacy, and offers configuration flexibility, making it an ideal solution for cooking enthusiasts, food bloggers, and small family projects.

In the era of digital technologies, where every aspect of our lives is moving online, cooking has not been left behind. Instead of scattered notes in notebooks and screenshots from websites, users are looking for a centralized and convenient solution for their recipe collection. Tandoor Recipes, or simply Tandoor, offers exactly that, providing a modern web interface for creating, editing, searching, and organizing recipes. But why choose Tandoor VPS over ready-made cloud solutions? The answer is simple: complete control, data security, and the ability to fine-tune settings to your unique needs. In this article, we will detail how to perform a Tandoor installation on your Valebyte.com virtual server, using Docker containerization, configure it for secure access via HTTPS, and ensure reliable maintenance.

What is Tandoor Recipes and why do you need it on a VPS?

Tandoor Recipes is an open-source project written in Python using the Django framework, offering a rich set of features for managing culinary recipes. It's not just a repository; it's an interactive platform that allows you to:

• Create and edit recipes with detailed instructions, ingredients, cooking times, and images.
• Organize recipes by categories, tags, and cuisines.
• Use powerful search with filters to quickly find desired dishes.
• Plan weekly menus.
• Create shopping lists based on selected recipes.
• Import recipes from popular online sources.
• Export recipes in various formats.
• Share recipes with friends and family, controlling access.
• Access your collection from any device via a web interface.

Choosing Tandoor self-hosted on your own VPS from Valebyte.com instead of cloud services or local installation on a home computer offers several undeniable advantages:

1. Full Data Control: Your recipes are your data. On a VPS, you have complete control over their storage, access, and backup, without relying on third-party providers.
2. Privacy and Security: By installing Tandoor on your own server, you minimize the risks of data leaks and unwanted information collection that can be inherent in free online services.
3. 24/7 Availability: Your VPS operates around the clock, providing constant access to your recipe collection from anywhere in the world with internet access. You don't need to keep your home computer turned on.
4. Flexibility and Scalability: You can easily scale VPS resources as your collection grows or the number of users increases. You can also integrate Tandoor with other self-hosted services on your server.
5. Cost-Effectiveness: In the long run, the cost of owning a VPS can be lower than subscribing to similar paid cloud services, especially if you already use a VPS for other projects.

Thus, Tandoor on a server is not just convenience, but an investment in your digital independence and data security.

System Requirements for Tandoor on a Server: Which VPS to Choose?

Before proceeding with the Tandoor installation, you need to ensure that your VPS meets the minimum system requirements. Tandoor is quite lightweight, especially for small recipe collections and a few users. However, if you plan to use it actively, import thousands of recipes, or provide access to a large number of people, you should consider more powerful configurations.

Minimum Requirements for Tandoor

• Operating System: Any modern Linux distribution (Ubuntu 20.04+, Debian 11+, CentOS 8+). Ubuntu Server LTS is recommended for its broad support and extensive documentation.
• Processor (CPU): 1 vCPU with a frequency of 2.0 GHz. Tandoor is not a CPU-intensive application for typical use.
• Random Access Memory (RAM): 1 GB. This will be sufficient for Tandoor and its PostgreSQL database to run in Docker containers. For more comfortable operation and the use of other services on the same VPS, 2 GB RAM would be more optimal.
• Disk Space: 10-20 GB NVMe SSD. Tandoor stores text recipe data and images. An NVMe SSD will significantly speed up database operations and image loading. 10 GB is enough for thousands of recipes without many images, 20 GB provides a buffer.
• Network Interface: Stable internet connection and a public IP address.

Recommended VPS Configurations for Tandoor under Different Loads

Choosing the optimal VPS configuration depends on the intended use. Valebyte.com offers various plans that can be adapted to your needs.

For most users starting with Tandoor, a plan with 2 vCPU, 2 GB RAM, and 40 GB NVMe SSD will be an excellent choice, providing comfortable operation and resource headroom. This will also allow you to host other useful services on the same VPS, such as for file management, like Filebrowser, or for monitoring, like Netdata.

Step-by-Step Tandoor Installation on VPS using Docker and Docker Compose

Tandoor installation using Docker and Docker Compose is the most recommended and straightforward deployment method. It provides application isolation, simplifies dependency management, and facilitates updates. We will use official Docker images.

VPS Preparation: Installing Docker and Docker Compose

The first step is to prepare your VPS. Ensure you are connected to it via SSH with `sudo` user privileges. All commands will be executed as this user.

1. System Update: Always start by updating the package database and installed packages.

   sudo apt update && sudo apt upgrade -y

2. Install Docker Engine:

   Install necessary packages:

   sudo apt install -y ca-certificates curl gnupg lsb-release

   Add Docker's official GPG key:

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

   Set up the Docker repository:

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

   Update the package database and install Docker Engine:

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

   Add the current user to the `docker` group to avoid using `sudo` for every Docker command (you'll need to log out and back in or restart your SSH session):

   sudo usermod -aG docker $USER

   Verify Docker installation:

   docker run hello-world

   You should see a "Hello from Docker!" message.

3. Install Docker Compose (V2):

   docker-compose-plugin is already installed with Docker Engine, but for convenience, you can create a symbolic link to use the `docker compose` command without the plugin:

   sudo ln -s /usr/local/lib/docker/cli-plugins/docker-compose /usr/bin/docker-compose # If the plugin is installed elsewhere, specify the correct path.
   # Or simply use 'docker compose' instead of 'docker-compose'

   Verify Docker Compose installation:

   docker compose version

   You will see version information.

Configuring Docker Compose for Tandoor

Now, let's create the `docker-compose.yml` file, which will define the services for Tandoor (the application itself, PostgreSQL database, and Redis for caching).

1. Create a directory for Tandoor:

   mkdir -p ~/tandoor_recipes
   cd ~/tandoor_recipes

2. Create the docker-compose.yml file:

   Open a text editor (e.g., nano):

   nano docker-compose.yml

   Paste the following content:

   version: "3.8"
   
   services:
     db:
       image: postgres:15-alpine
       container_name: tandoor_db
       restart: unless-stopped
       volumes:
         - ./data/db:/var/lib/postgresql/data
       env_file:
         - .env
       healthcheck:
         test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]
         interval: 5s
         timeout: 5s
         retries: 5
   
     redis:
       image: redis:7-alpine
       container_name: tandoor_redis
       restart: unless-stopped
       volumes:
         - ./data/redis:/data
       healthcheck:
         test: ["CMD", "redis-cli", "ping"]
         interval: 5s
         timeout: 5s
         retries: 5
   
     tandoor:
       image: ghcr.io/tandoorrecipes/tandoor-recipes:stable
       container_name: tandoor_app
       restart: unless-stopped
       ports:
         - "8000:8000" # Port for Tandoor access. Change 8000:8000 if 8000 is occupied.
       volumes:
         - ./data/media:/opt/tandoor/media
         - ./data/static:/opt/tandoor/static
         - ./data/export:/opt/tandoor/export
       env_file:
         - .env
       depends_on:
         db:
           condition: service_healthy
         redis:
           condition: service_healthy
       healthcheck:
         test: ["CMD", "curl", "-f", "http://localhost:8000/api/docs/"]
         interval: 30s
         timeout: 10s
         retries: 5
         start_period: 30s

   Save the file (Ctrl+X, Y, Enter).

3. Create the environment variables file .env:

   This file will contain sensitive data, such as database passwords. Create it:

   nano .env

   Paste the following content, replacing YOUR_DB_PASSWORD, YOUR_SECRET_KEY, and YOUR_EMAIL_HOST_PASSWORD with strong, generated values. SECRET_KEY should be a long random string.

   # Database
   POSTGRES_DB=tandoor
   POSTGRES_USER=tandoor
   POSTGRES_PASSWORD=YOUR_DB_PASSWORD # Generate a strong password
   
   # Tandoor
   SECRET_KEY=YOUR_SECRET_KEY # Generate a long random string (e.g., openssl rand -hex 32)
   DEBUG=False # Always False for production
   ALLOWED_HOSTS=* # Will be replaced with your domain later
   
   # Email (optional, if you don't plan to send notifications)
   EMAIL_HOST=smtp.your-email-provider.com
   EMAIL_PORT=587
   [email protected]
   EMAIL_HOST_PASSWORD=YOUR_EMAIL_HOST_PASSWORD # Your email password
   EMAIL_USE_TLS=True
   DEFAULT_FROM_EMAIL=Tandoor Recipes <[email protected]>
   SERVER_EMAIL=Tandoor Recipes <[email protected]>

   Important: For SECRET_KEY, you can use the command openssl rand -hex 32 to generate a strong key. Replace YOUR_DB_PASSWORD with something like tr_StrongPassw0rd!123. Store this data in a secure location.

   Save the file (Ctrl+X, Y, Enter).

Starting Tandoor Recipes

Once `docker-compose.yml` and `.env` are configured, you can start Tandoor.

1. Start containers:

   In the ~/tandoor_recipes directory, execute the command:

   docker compose up -d

   This command will download images, create containers, and run them in the background (-d).

2. Check container status:

   docker compose ps

   All containers should be in the running state, and tandoor_app and tandoor_db should also show healthy.

3. Create a Tandoor superuser:

   This is necessary for the first login. Execute the command inside the tandoor_app container:

   docker compose exec tandoor_app python manage.py createsuperuser

   Follow the on-screen instructions to enter a username, email address, and password. Remember these credentials, as they will be used for logging in.

4. First login:

   Tandoor is now accessible via your VPS's IP address on port 8000. For example, http://YOUR_VPS_IP:8000. Open this address in your browser and log in using the superuser credentials you created.

   Congratulations! Tandoor Docker is up and running. However, for production use, you need to configure a reverse proxy and HTTPS.

Configuring Reverse Proxy and HTTPS for Tandoor: Nginx or Caddy?

Direct access to Tandoor on port 8000 is neither secure nor convenient. We need a Reverse Proxy to handle web requests on standard ports (80 for HTTP, 443 for HTTPS) and redirect them to the Tandoor container. It is also crucial to configure HTTPS for traffic encryption. We will look at two popular options: Nginx and Caddy.

For this step, you will need a domain name pointing to your VPS's IP address (e.g., recipes.your-domain.com).

Configuring Nginx as a Reverse Proxy

Nginx is a powerful and widely used web server that is excellent for acting as a reverse proxy. It requires manual certificate configuration, typically via Certbot.

1. Install Nginx:

   sudo apt install -y nginx

2. Create a configuration file for Tandoor:

   Create a new configuration file for your domain:

   sudo nano /etc/nginx/sites-available/tandoor.conf

   Paste the following content, replacing recipes.your-domain.com with your domain name:

   server {
       listen 80;
       server_name recipes.your-domain.com;
       client_max_body_size 50M;
   
       location / {
           proxy_pass http://localhost:8000;
           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;
           proxy_redirect off;
       }
   
       location /static/ {
           alias /home/$USER/tandoor_recipes/data/static/;
       }
   
       location /media/ {
           alias /home/$USER/tandoor_recipes/data/media/;
       }
   }

   Important note: Replace /home/$USER/tandoor_recipes/data/static/ and /home/$USER/tandoor_recipes/data/media/ with the actual paths to your static and media directories within the Tandoor directory. You can find out the current user with the `whoami` command.

   Save the file.

3. Activate the configuration:

   Create a symbolic link to the file in sites-enabled:

   sudo ln -s /etc/nginx/sites-available/tandoor.conf /etc/nginx/sites-enabled/

   Test Nginx syntax and reload it:

   sudo nginx -t
   sudo systemctl reload nginx

   Tandoor should now be accessible via HTTP through your domain: http://recipes.your-domain.com.

4. Configure HTTPS with Certbot (Let's Encrypt):

   Install Certbot and the Nginx plugin:

   sudo apt install -y certbot python3-certbot-nginx

   Run Certbot to obtain and install the certificate:

   sudo certbot --nginx -d recipes.your-domain.com

   Follow the instructions. Certbot will automatically modify the Nginx configuration to use HTTPS and set up automatic certificate renewal.

5. Update Tandoor's .env file:

   Edit the .env file so Tandoor knows about the domain:

   nano ~/tandoor_recipes/.env

   Change ALLOWED_HOSTS to your domain name:

   ALLOWED_HOSTS=recipes.your-domain.com

   Restart the Tandoor container to apply changes:

   docker compose restart tandoor

   Tandoor is now accessible via HTTPS: https://recipes.your-domain.com.

Configuring Caddy as a Reverse Proxy

Caddy is a modern web server that automatically manages Let's Encrypt HTTPS certificates. This makes it significantly easier to configure compared to Nginx + Certbot.

1. Install Caddy:

   Install necessary packages:

   sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https

   Add Caddy's GPG key:

   curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg

   Add the Caddy repository:

   curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list

   Update the package database and install Caddy:

   sudo apt update
   sudo apt install -y caddy

2. Create the Caddyfile configuration file:

   Stop and disable the standard Caddy service:

   sudo systemctl stop caddy
   sudo systemctl disable caddy

   Create a new Caddyfile for Tandoor:

   sudo nano /etc/caddy/Caddyfile

   Paste the following content, replacing recipes.your-domain.com with your domain name:

   recipes.your-domain.com {
       reverse_proxy localhost:8000
       file_server /static/* {
           root /home/$USER/tandoor_recipes/data/
       }
       file_server /media/* {
           root /home/$USER/tandoor_recipes/data/
       }
   }

   Important note: Replace /home/$USER/tandoor_recipes/data/ with the actual path to your data directory within the Tandoor directory. Caddy will automatically look for static and media within this root.

   Save the file.

3. Start Caddy with the new configuration:

   Validate the Caddyfile syntax:

   sudo caddy validate --config /etc/caddy/Caddyfile

   If there are no errors, restart Caddy:

   sudo systemctl enable caddy
   sudo systemctl start caddy

   Caddy will automatically obtain a Let's Encrypt certificate and configure HTTPS.

4. Update Tandoor's .env file:

   Edit the .env file:

   nano ~/tandoor_recipes/.env

   Change ALLOWED_HOSTS to your domain name:

   ALLOWED_HOSTS=recipes.your-domain.com

   Restart the Tandoor container to apply changes:

   docker compose restart tandoor

   Tandoor is now accessible via HTTPS: https://recipes.your-domain.com.

Tandoor Maintenance on VPS: Backups and Updates

Regular maintenance is key to the stable and secure operation of any self-hosted application. For Tandoor, this includes creating backups and timely updates.

Tandoor Data Backup Strategies

Backup is a critically important aspect. If you already use Restic for backups, you can easily integrate Tandoor data as well. Tandoor stores all its important data in two places: the PostgreSQL database and the media files directory.

1. What needs to be backed up:
   • PostgreSQL Database: Contains all text recipe data, users, settings.
   • media Directory: Contains all uploaded recipe images.
   • .env File: Contains important environment variables and secret keys.
2. Manual Backup (for understanding the process):

   Dump the database:

   docker compose exec db pg_dump -U tandoor tandoor > ~/tandoor_recipes/backup/tandoor_db_$(date +%Y%m%d_%H%M%S).sql

   Archive the media directories and .env file:

   tar -czvf ~/tandoor_recipes/backup/tandoor_media_$(date +%Y%m%d_%H%M%S).tar.gz -C ~/tandoor_recipes/data media .env

   Create the backup directory if it doesn't exist:

   mkdir -p ~/tandoor_recipes/backup

3. Automated Backup (recommended):

   Use a script and cron for automation. Create a file named backup_tandoor.sh in the Tandoor directory:

   nano ~/tandoor_recipes/backup_tandoor.sh

   Paste the content:

   #!/bin/bash
   
   BACKUP_DIR="/home/$USER/tandoor_recipes/backup"
   TIMESTAMP=$(date +%Y%m%d_%H%M%S)
   DB_BACKUP_FILE="$BACKUP_DIR/tandoor_db_${TIMESTAMP}.sql"
   MEDIA_BACKUP_FILE="$BACKUP_DIR/tandoor_media_${TIMESTAMP}.tar.gz"
   ENV_FILE="/home/$USER/tandoor_recipes/.env"
   
   mkdir -p "$BACKUP_DIR"
   
   # Backup PostgreSQL database
   docker compose exec db pg_dump -U tandoor tandoor > "$DB_BACKUP_FILE"
   if [ $? -eq 0 ]; then
       echo "Database backup successful: $DB_BACKUP_FILE"
   else
       echo "Database backup FAILED!"
   fi
   
   # Backup media files and .env
   tar -czvf "$MEDIA_BACKUP_FILE" -C /home/$USER/tandoor_recipes/data media "$ENV_FILE"
   if [ $? -eq 0 ]; then
       echo "Media and .env backup successful: $MEDIA_BACKUP_FILE"
   else
       echo "Media and .env backup FAILED!"
   fi
   
   # Clean up old backups (e.g., keep last 7 days)
   find "$BACKUP_DIR" -type f -name "tandoor_db_*.sql" -mtime +7 -delete
   find "$BACKUP_DIR" -type f -name "tandoor_media_*.tar.gz" -mtime +7 -delete
   
   echo "Tandoor backup script finished."

   Make the script executable:

   chmod +x ~/tandoor_recipes/backup_tandoor.sh

   Add a task to cron (e.g., daily backup at 3:00 AM):

   crontab -e

   Add the line:

   0 3 * * * /home/$USER/tandoor_recipes/backup_tandoor.sh >> /var/log/tandoor_backup.log 2>&1

   This will run the script daily and log the output to /var/log/tandoor_backup.log.

Updating Tandoor and Docker Containers

Updating Tandoor via Docker Compose is very straightforward.

1. Before updating:

   Always make a backup before updating! This is a golden rule.

   Familiarize yourself with the official Tandoor update documentation to learn about potential changes or special steps for a specific version.

2. Update process:

   Navigate to the Tandoor directory:

   cd ~/tandoor_recipes

   Stop the containers:

   docker compose down

   Download the latest image versions:

   docker compose pull

   Start the containers with the new images. Docker Compose will automatically update the containers and apply database changes if necessary:

   docker compose up -d

   If there are database migrations, Tandoor may run them automatically on startup. If not, or if issues arise, you can run migrations manually:

   docker compose exec tandoor_app python manage.py migrate

   Clear the cache (this is good practice after an update):

   docker compose exec tandoor_app python manage.py clear_cache

   Check container logs for errors:

   docker compose logs tandoor_app

Optimal VPS Config for Tandoor under Real-World Load

Choosing a VPS for Tandoor depends not only on the number of recipes but also on usage intensity, the number of concurrent users, and the presence of other services on the same server.

• For personal use or a small family (1-3 users):

  2 vCPU, 2 GB RAM, 40 GB NVMe SSD. This configuration will ensure smooth Tandoor operation, even with several images and active searching. There will also be enough resources left for installing other useful utilities, such as for backups or monitoring. The cost of such a VPS on Valebyte.com typically starts from $10-15 per month.

• For an active food blog or community (5-15+ users):

  4 vCPU, 4-8 GB RAM, 80-160 GB NVMe SSD. Under such a load, the need for RAM increases to handle simultaneous requests and data caching. A more powerful processor will speed up indexing and complex search queries. Increased disk space is needed for a large number of images and potential videos. The cost can vary from $20 to $40+ per month.

• Factors influencing choice:
  • Disk Type: Always choose NVMe SSD. The performance difference compared to regular SSDs or HDDs is immense, especially for the database and image loading.
  • Server Location: Choose a data center that is geographically close to your primary users to minimize latency.
  • Use of other Docker containers: If you plan to host other applications on the same VPS (e.g., Mealie as an alternative, Home Assistant, or Authelia for authentication), allocate additional resources. Each container requires its share of CPU and RAM.
  • Network Bandwidth: Valebyte.com offers high-speed ports (typically 1 Gbit/s), which is critical for fast loading of images and media files.

It's always best to start with a minimally sufficient plan and scale resources as needed. Valebyte.com virtual servers allow you to easily upgrade your configuration without reinstalling the system.

Conclusion

Installing Tandoor on a VPS from Valebyte.com using Docker and Docker Compose provides a powerful, flexible, and fully controlled solution for managing your recipe collection. By following this step-by-step guide, you will be able to deploy Tandoor, secure it with HTTPS, and set up regular maintenance, ensuring that your culinary treasures are always accessible and protected.