How to install Mealie on Debian 12 with Docker + SSL

Mealie (Recipe Manager) on Debian 12

Mealie is a modern, open-source self-hosted recipe manager and meal-planning platform built to help you organize recipes, plan meals, generate shopping lists, and collaborate with family or teams. It supports recipe imports from popular websites, Markdown-based editing, nutrition calculations, and multi-user access, making it a powerful alternative to cloud-based cooking and meal-planning apps.

Unlike SaaS recipe platforms, Mealie keeps all your data on your own server. Recipes, images, meal plans, and user data never leave your infrastructure, which makes Mealie ideal for privacy-conscious users, families, and self-hosting enthusiasts.

Running Mealie on Debian 12 (Bookworm) provides a stable, secure, and long-term supported foundation. Debian 12 ships with systemd 252, OpenSSL 3, and mature Docker and Nginx packages, making it an excellent choice for deploying Mealie with Docker, PostgreSQL, Nginx, and HTTPS (SSL) in a production-ready setup.

Architecture Overview

Layer	Component	Role
OS	Debian 12 (Bookworm)	Stable, production-grade Linux base
Container Runtime	Docker / Docker Compose	Runs Mealie and supporting services
Application	Mealie (Python + FastAPI)	Recipe management, meal planning, REST API
Database	PostgreSQL	Stores recipes, users, meal plans, metadata
Reverse Proxy	Nginx	HTTPS termination, routing, compression
TLS	Let’s Encrypt / PKI	Secure encrypted access to the web interface

Mealie’s containerized design makes it easy to deploy, upgrade, migrate, and back up, even on small VPS or home servers.

Why Use Mealie?

Self-hosted recipe manager – full ownership of your cooking data
Recipe importers – save recipes directly from supported websites
Meal planning & calendars – plan meals days or weeks in advance
Automatic shopping lists – generated from your meal plans
Multi-user support – ideal for families or shared kitchens
Nutrition data & unit conversions – useful for diet tracking
Clean, modern UI – responsive and mobile-friendly
Open-source & actively developed – transparent and extensible

Mealie is designed for users who want organization, automation, and privacy in their kitchen workflow.

Mealie vs Other Recipe Platforms

Feature / Capability	Mealie	Paprika	Yummly	Tandoor
Hosting	Self-hosted	App-based	Cloud only	Self-hosted
Meal planning	✅ Yes	✅ Yes	❌ Limited	✅ Yes
Shopping lists	✅ Yes	✅ Yes	❌ Limited	✅ Yes
Multi-user	✅ Yes	❌ No	❌ No	✅ Yes
Privacy	Full control	App-dependent	Cloud-based	Full control
Cost	Free, open-source	Paid app	Free / Paid	Free

Mealie offers an excellent balance between ease of use, collaboration, and self-hosting.

Security & Best Practices on Debian 12

Run Mealie behind Nginx with HTTPS enabled.
Keep Mealie and PostgreSQL restricted to internal Docker networks.
Store secrets (database passwords, JWT secrets) using environment variables.
Use UFW or nftables and allow only ports 80 and 443.
Automate SSL certificate renewal with Certbot.
Regularly update Debian, Docker, and Mealie images.
Back up:
- PostgreSQL database
- Mealie configuration
- Uploaded images and assets
Create separate user accounts and restrict admin access.
Disable public registration if Mealie is used privately.

Typical Use Cases

Personal recipe collections – replace cloud cooking apps
Family meal planning – shared recipes and shopping lists
Home-lab lifestyle tools – private, self-hosted daily utilities
Diet & nutrition tracking – structured meals and portions
Content creators – manage large recipe libraries
Small communities – collaborative cooking platforms

Deploying Mealie on Debian 12 with Docker and SSL gives you a secure, private, and feature-rich recipe management platform — combining modern meal-planning tools with full data ownership and Debian’s legendary stability.

Step 1: Create a Server Instance on Shape.Host

Before installing Mealie, you need a VPS.

Click Create from the dashboard and select Instance.

Choose a data center location close to your users.

Shape.host instance form with the data center location selector highlighted.

Select a VPS plan with at least:

2 CPU cores

4 GB RAM

30 GB SSD storage

Shape.host instance form with the operating system image selector highlighted.

Choose Debian 12 (Bookworm) as the operating system.

Create the instance and wait for provisioning.

Shape.host instance form with the Create Instance button highlighted.

Copy the public IP address of the server.

This server will host Docker, Mealie, PostgreSQL, Nginx, and SSL.

Shape.host Resources dashboard with the server IP address highlighted.

Step 2: Connect to the Debian 12 Server

Linux / macOS

ssh root@YOUR_SERVER_IP

Windows

Use PowerShell, Windows Terminal, or PuTTY:

ssh root@YOUR_SERVER_IP

Once connected, you should be logged in as root.

Step 3: Install Mealie with Docker Compose

3.1 Update the System

apt update

Updates the package index.

apt upgrade -y

Upgrades all installed packages.

Terminal showing APT package management commands and output.

3.2 Install Required Dependencies

apt install ca-certificates curl gnupg lsb-release

Installs tools required for secure repository management.

mkdir -p /etc/apt/keyrings

Creates a directory for trusted GPG keys.

3.3 Add Docker Repository

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

Downloads and registers Docker’s GPG key.

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

Adds the Docker repository for Debian 12.

apt update

Refreshes package lists.

3.4 Install Docker and Docker Compose

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

Installs Docker Engine and Docker Compose plugin.

docker --version

Verifies Docker installation.

docker compose version

Verifies Docker Compose availability.

Step 4: Configure Mealie

4.1 Create Project Directory

mkdir -p /opt/mealie

cd /opt/mealie

Terminal showing the installed Docker Compose version.

4.2 Create Docker Compose File

nano docker-compose.yml

Paste the following configuration:

services:
  db:
    image: postgres:16
    container_name: mealie-db
    restart: unless-stopped
    environment:
      POSTGRES_DB: mealie
      POSTGRES_USER: mealie
      POSTGRES_PASSWORD: strong_db_password
    volumes:
      - /opt/mealie/db:/var/lib/postgresql/data

  mealie:
    image: ghcr.io/mealie-recipes/mealie:latest
    container_name: mealie
    restart: unless-stopped
    ports:
      - "127.0.0.1:9000:9000"
    environment:
      ALLOW_SIGNUP: "false"
      DB_ENGINE: postgres
      POSTGRES_DB: mealie
      POSTGRES_USER: mealie
      POSTGRES_PASSWORD: strong_db_password
      POSTGRES_SERVER: db
      POSTGRES_PORT: 5432
      BASE_URL: https://mealie.example.com
    volumes:
      - /opt/mealie/data:/app/data
    depends_on:
      - db

This setup:

Uses PostgreSQL 16 as the database backend
Restricts Mealie access to localhost
Prepares the app for reverse proxy and HTTPS

Terminal showing the GNU nano editor and configuration text.

4.3 Create Persistent Storage Directories

mkdir -p /opt/mealie/db

mkdir -p /opt/mealie/data

Terminal showing file and directory setup commands.

4.4 Start Mealie

docker compose pull

Pulls the latest Mealie and PostgreSQL images.

docker compose up -d

Starts the containers in detached mode.

docker compose ps

Confirms that the containers are running.

Terminal showing container image download progress.

Step 5: Configure Nginx Reverse Proxy

5.1 Install and Check Nginx

apt install nginx

systemctl status nginx

Terminal showing systemd service management commands or output.

5.2 Create Nginx Virtual Host

nano /etc/nginx/sites-available/mealie

Paste:

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

    client_max_body_size 100M;

    location / {
        proxy_pass http://127.0.0.1:9000;
        proxy_http_version 1.1;

        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;
    }
}

5.3 Enable the Site

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

rm /etc/nginx/sites-enabled/default

nginx -t

systemctl reload nginx

Step 6: Enable SSL with Let’s Encrypt

apt install certbot python3-certbot-nginx

certbot --nginx -d debian-tutorials.shape.host

Terminal showing Certbot certificate commands and messages.

Replace with your actual domain if needed:

yourdomain.com

Certbot will automatically:

Issue an SSL certificate
Configure Nginx for HTTPS
Enable automatic certificate renewal

Step 7: Verify the Installation

Open your browser: https://mealie.example.com

Mealie sign-in form with an informational banner.

Mealie welcome screen with an option to create a recipe.

Check container status:

docker compose ps

Verify Nginx:

systemctl status nginx

If Mealie loads correctly over HTTPS, the installation is complete.

You installed Mealie on Debian 12 using Docker Compose, connected it to a PostgreSQL database, exposed it via Nginx, and secured it with Let’s Encrypt SSL. This setup is robust, secure, and ideal for personal or family recipe management.

For hosting self-hosted applications like Mealie with excellent performance, scalability, and full root access, Shape.Host Cloud VPS is a reliable choice for modern server workloads.