Mealie on VPS: installation, setup, and maintenance

Installing Mealie on a VPS is an effective way to create your own platform for storing and managing recipes, providing full control over data, high performance, and scalability, which is ideal for culinary enthusiasts, food bloggers, and small teams seeking independence from third-party services.

What is Mealie and Why Install Mealie on a VPS?

Mealie is a modern, open-source, and API-first recipe management application that allows you to store, organize, share, and even plan meals. Imagine a digital cookbook that's always with you, accessible from any device, and completely under your control. It's a Mealie self-hosted solution that provides functionality for importing recipes from popular websites, editing, creating shopping lists, and much more. It's written in Python using FastAPI for the backend and Vue.js for the frontend, ensuring a fast and responsive user interface.

Choosing Mealie on a VPS instead of cloud or third-party solutions offers several significant advantages:

• Full Data Control: All your recipes, notes, and personal information are stored on your own server, not on third-party servers. This is critically important for privacy and security.
• Customization and Scalability: You can configure Mealie to your unique needs, changing server configuration as your recipe storage requirements or user count grows.
• Performance: With a properly configured VPS, you get guaranteed resources (CPU, memory, disk), ensuring stable and fast application performance without the influence of "neighbors" on shared hosting.
• Integration: Mealie easily integrates with other self-hosted services thanks to its API. For example, you can set up automatic backups to your NAS or integrate with third-party meal planning tools.
• Learning and Development: Self-Mealie installation and maintenance on a VPS is an excellent opportunity to deepen your knowledge in server administration, Docker, and web technologies.

Valebyte.com offers reliable VPS servers that are ideal for tasks like hosting Mealie, providing you with a powerful and flexible infrastructure for your projects.

Key Features of Mealie

Mealie is not just a recipe repository. It's a full-fledged platform with a rich set of features:

• Recipe Import: Supports importing recipes from over 100 popular cooking websites and blogs, as well as manual entry and editing.
• Ingredient and Step Management: Detailed descriptions of ingredients, quantities, units of measurement, and step-by-step cooking instructions.
• Categories and Tags: Flexible categorization and tagging system for easy recipe search and organization.
• Meal Planning: Built-in calendar for planning meals for the week or month.
• Shopping Lists: Automatic creation of shopping lists based on selected recipes, with the ability to combine ingredients and manually add items.
• Users and Permissions: Supports multiple users with different access levels, making Mealie an excellent solution for a family or small team.
• Tags and Search: Powerful full-text search across all recipe fields, as well as filtering by tags, categories, and other attributes.
• Dark Mode: Convenient dark mode for working in low-light conditions.
• PWA Compatibility: Ability to install Mealie as a Progressive Web App on mobile devices for quick access.

System Requirements for Mealie on a Server

Choosing the right VPS server for Mealie on a server is crucial for ensuring its stable and fast operation. While Mealie is relatively lightweight, especially for a small number of users, it's important to consider the minimum and recommended requirements. These requirements are based on a typical configuration using Docker and a PostgreSQL database.

Minimum Requirements

For a single user or a very small family (1-3 people) with a few hundred recipes:

• Processor (CPU): 1 vCPU with a clock speed of 2.0 GHz or higher. Mealie is not a CPU-intensive application under standard use, but a processor is needed for request processing and background tasks.
• RAM (Memory): 1 GB. This is sufficient for running Mealie and PostgreSQL Docker containers. PostgreSQL can consume up to 200-300 MB, and Mealie itself 200-400 MB at idle.
• Disk Space: 10-15 GB NVMe SSD. Mealie stores recipes, images, and the database. NVMe SSD will significantly speed up I/O operations, which is important for application responsiveness. 10-15 GB is enough for several thousand recipes and their images, as well as for the operating system and Docker images.
• Operating System: Ubuntu 22.04 LTS, Debian 11/12, or CentOS 8/9. LTS versions are recommended for stability and long-term support.
• Network Connection: Minimum 100 Mbit/s. Mealie does not require high bandwidth, but a stable connection is important for access.

Recommended Requirements

For active use (3-10 users) with thousands of recipes, frequent imports, and planning:

• Processor (CPU): 2 vCPU with a clock speed of 2.5 GHz or higher. An additional core will provide better parallel request processing, especially with simultaneous access from multiple users or when performing resource-intensive operations such as importing a large number of recipes.
• RAM (Memory): 2-4 GB. This will provide sufficient buffer for PostgreSQL and Mealie, preventing data from being swapped out and improving overall performance. If you plan to run other services on the same VPS, 4 GB would be a safer choice.
• Disk Space: 25-50 GB NVMe SSD. A larger disk volume will provide room for growth in the number of recipes, images, and for storing backups. NVMe SSD remains the preferred choice.
• Operating System: Ubuntu 22.04 LTS or Debian 12.
• Network Connection: 1 Gbit/s.

It's important to remember that these requirements are approximate. Actual resource consumption may vary depending on the number of users, frequency of use, quantity of recipes and images, as well as other applications running on the same VPS. It's always better to start with a slightly larger configuration than the minimum to allow for growth and avoid performance issues.

Preparing Your VPS for Mealie Docker Installation

Before proceeding with Mealie installation, you need to prepare your VPS. We will use Docker and Docker Compose for the simplest and most portable installation. Make sure you have SSH access to the server with sudo user privileges.

Updating the System and Installing Necessary Packages

First, update all system packages to ensure security and stability:

sudo apt update
sudo apt upgrade -y
sudo apt autoremove -y

Then install some utilities that might be needed:

sudo apt install -y curl wget git nano htop

Installing Docker Engine

Mealie will run in Docker containers. Installing Docker Engine is the next important step.

1. Remove old Docker versions (if any):

   for pkg in docker.io docker-doc docker-compose docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin; do sudo apt remove $pkg; done

2. Install necessary dependencies:

   sudo apt install -y ca-certificates curl gnupg

3. Add Docker's official GPG key:

   sudo install -m 0755 -d /etc/apt/keyrings
   curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
   sudo chmod a+r /etc/apt/keyrings/docker.gpg

4. Add the Docker repository to APT sources:

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

5. Update the APT index and install Docker Engine:

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

6. Add your user to the docker group: This will allow you to run Docker commands without sudo.

   sudo usermod -aG docker $USER

   To apply the changes, you need to log out of your SSH session and log back in.

7. Verify Docker installation:

   docker run hello-world

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

Installing Docker Compose

Docker Compose is required to manage multi-container applications like Mealie, which typically consists of application and database containers. The Docker Compose Plugin is already installed with Docker Engine, but if you're using an older Docker version or a different OS, you might need to install it manually. Make sure the docker compose command works (without a hyphen).

docker compose version

If you see a version, then everything is fine. If not, you might need to install it as a standalone binary:

sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Then check the version: docker-compose version (with a hyphen). In newer Docker versions, it's preferable to use docker compose (without a hyphen).

Step-by-Step Mealie Installation on a VPS with Docker Compose

Now that your VPS is ready, we can proceed with deploying Mealie Docker using Docker Compose. This method allows for easy management of the application and its dependencies.

Creating a Directory for Mealie

Create a directory where all Mealie configuration files and data will be stored:

mkdir -p ~/mealie
cd ~/mealie

Configuring the .env file

Mealie uses environment variables for its configuration. Create a .env file in the ~/mealie directory:

nano .env

And add the following content:

# Mealie Configuration
TZ=Europe/Moscow # Your time zone
PUID=1000 # Your user ID (usually 1000)
PGID=1000 # Your group ID (usually 1000)
APP_HOST=0.0.0.0 # Listen on all interfaces
APP_PORT=9000 # Port on which Mealie will be accessible inside the container
BASE_URL=http://localhost:9000 # Will be changed when setting up the proxy

# Database Configuration (PostgreSQL)
DB_ENGINE=postgresql
DB_HOST=db
DB_PORT=5432
DB_USER=mealie
DB_PASSWORD=your_strong_db_password # Replace with a strong password
DB_NAME=mealie

# Mealie Specific
DEBUG=false # Set to true for debugging
ALLOW_SIGNUP=true # Allow self-registration for users (can be disabled after creating admin)
SECRET_KEY=generate_a_very_long_random_string # Generate a long random string (minimum 32 characters)
MEDIA_LOCATION=/app/data/media # Path for media files inside the container
DATA_LOCATION=/app/data # Path for data inside the container

# SMTP Configuration (Optional, for sending emails)
SMTP_HOST=
SMTP_PORT=
SMTP_USER=
SMTP_PASSWORD=
SMTP_FROM_EMAIL=
SMTP_TLS=true
SMTP_SSL=false

Important notes:

• Replace your_strong_db_password with a complex, unique password.
• For SECRET_KEY, generate a very long random string (e.g., using openssl rand -hex 32).
• PUID and PGID can be found using the commands id -u and id -g respectively. This is usually 1000 for the first user in Linux.
• Change TZ to your time zone (e.g., Europe/Berlin, America/New_York).
• It is recommended to disable ALLOW_SIGNUP after creating the first administrator to prevent unauthorized registrations.
• If you plan to use Mealie for password recovery or notifications, configure the SMTP parameters.

Creating the docker-compose.yml file

Create a docker-compose.yml file in the same ~/mealie directory:

nano docker-compose.yml

And add the following content:

version: '3.8'

services:
  mealie:
    image: hkotel/mealie:latest # Uses the official Mealie image
    container_name: mealie
    environment:
      - TZ=${TZ}
      - PUID=${PUID}
      - PGID=${PGID}
      - APP_HOST=${APP_HOST}
      - APP_PORT=${APP_PORT}
      - BASE_URL=${BASE_URL}
      - DB_ENGINE=${DB_ENGINE}
      - DB_HOST=${DB_HOST}
      - DB_PORT=${DB_PORT}
      - DB_USER=${DB_USER}
      - DB_PASSWORD=${DB_PASSWORD}
      - DB_NAME=${DB_NAME}
      - DEBUG=${DEBUG}
      - ALLOW_SIGNUP=${ALLOW_SIGNUP}
      - SECRET_KEY=${SECRET_KEY}
      - MEDIA_LOCATION=${MEDIA_LOCATION}
      - DATA_LOCATION=${DATA_LOCATION}
      # SMTP (uncomment and fill if used)
      # - SMTP_HOST=${SMTP_HOST}
      # - SMTP_PORT=${SMTP_PORT}
      # - SMTP_USER=${SMTP_USER}
      # - SMTP_PASSWORD=${SMTP_PASSWORD}
      # - SMTP_FROM_EMAIL=${SMTP_FROM_EMAIL}
      # - SMTP_TLS=${SMTP_TLS}
      # - SMTP_SSL=${SMTP_SSL}
    volumes:
      - ./data:/app/data # Binds the local directory for data storage
    ports:
      - "9000:9000" # Forwards Mealie's port to the host system
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: postgres:15-alpine # Uses a lightweight PostgreSQL image
    container_name: mealie_db
    environment:
      - POSTGRES_DB=${DB_NAME}
      - POSTGRES_USER=${DB_USER}
      - POSTGRES_PASSWORD=${DB_PASSWORD}
      - TZ=${TZ}
    volumes:
      - ./db-data:/var/lib/postgresql/data # Binds the local directory for DB data storage
    restart: unless-stopped

volumes:
  data:
  db-data:

Explanation of docker-compose.yml:

• mealie service:
  • image: hkotel/mealie:latest: Uses the latest stable version of Mealie.
  • environment: Passes variables from the .env file to the Mealie container.
  • volumes: - ./data:/app/data: Mounts the local data directory (which will be created next to docker-compose.yml) into the container at the path /app/data. All Mealie user data (recipes, images, configuration) will be stored here.
  • ports: - "9000:9000": Forwards port 9000 of the Mealie container to port 9000 of the host system. This allows access to Mealie via your VPS's IP address and port 9000.
  • depends_on: - db: Indicates that the mealie service depends on the db service. Docker Compose will start the database first.
  • restart: unless-stopped: Ensures that the Mealie container will automatically restart if it stops or the server reboots.
• db service:
  • image: postgres:15-alpine: Uses the lightweight PostgreSQL 15 image.
  • environment: Passes parameters for PostgreSQL database initialization from the .env file.
  • volumes: - ./db-data:/var/lib/postgresql/data: Mounts the local db-data directory into the container for persistent storage of PostgreSQL data.
  • restart: unless-stopped: Similar for the database.

Starting Mealie

Save both files (.env and docker-compose.yml). Now you are ready to start Mealie.

In the ~/mealie directory, execute the command:

docker compose up -d

This command will download the necessary Docker images (if not present), create, and start the Mealie and PostgreSQL containers in the background (-d means detached mode).

You can check the status of the running containers:

docker compose ps

Both containers (mealie and mealie_db) should have a status of Up.

Mealie should now be accessible at http://YOUR_VPS_IP:9000. Upon first access, you will be prompted to create an administrator account. After creating the administrator, it is recommended to edit the .env file and set ALLOW_SIGNUP=false to prevent unauthorized registration of other users.

For further data control and preservation, consider using Filebrowser on a VPS: Installation, Configuration, and Maintenance, which will help you manage files related to Mealie and organize their backups.

Setting up a Reverse Proxy and HTTPS for Mealie

Accessing Mealie via http://YOUR_VPS_IP:9000 is neither secure nor convenient. To ensure secure access via a domain name with HTTPS (SSL certificate) and the ability to run Mealie on the standard port 443, you need to set up a reverse proxy server. We will cover two popular options: Nginx and Caddy.

Before you begin, ensure you have a domain name (e.g., recipes.mydomain.com) pointing to your VPS's IP address.

Option 1: Nginx with Let's Encrypt

Nginx is a powerful and widely used web server and reverse proxy. Let's Encrypt provides free SSL certificates.

1. Installing Nginx

sudo apt install -y nginx

2. Configuring Nginx

Create a new configuration file for your domain:

sudo nano /etc/nginx/sites-available/recipes.mydomain.com

Add the following content, replacing recipes.mydomain.com with your domain:

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

    location / {
        return 301 https://$host$request_uri;
    }
}

server {
    listen 443 ssl http2;
    server_name recipes.mydomain.com;

    ssl_certificate /etc/letsencrypt/live/recipes.mydomain.com/fullchain.pem; # These paths will be created by Certbot
    ssl_certificate_key /etc/letsencrypt/live/recipes.mydomain.com/privkey.pem; # These paths will be created by Certbot

    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;

    location / {
        proxy_pass http://localhost:9000; # Port on which Mealie is accessible on the host
        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;
    }
}

Important changes in .env:

After setting up the reverse proxy, go back to the .env file in the ~/mealie directory and change BASE_URL to your domain with HTTPS:

BASE_URL=https://recipes.mydomain.com

Restart Mealie for the changes to take effect:

cd ~/mealie
docker compose restart mealie

3. Activating Nginx Configuration

sudo ln -s /etc/nginx/sites-available/recipes.mydomain.com /etc/nginx/sites-enabled/
sudo nginx -t # Syntax check
sudo systemctl restart nginx

4. Installing Certbot and Obtaining an SSL Certificate

sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d recipes.mydomain.com

Follow Certbot's instructions. It will automatically configure Nginx to use HTTPS. Certbot will also create a cron job for automatic certificate renewal.

Option 2: Caddy (simpler)

Caddy is a modern web server that automatically manages Let's Encrypt SSL certificates, significantly simplifying HTTPS setup.

1. Installing Caddy

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install -y caddy

2. Configuring Caddyfile

Create or edit the file /etc/caddy/Caddyfile:

sudo nano /etc/caddy/Caddyfile

Remove all default content and add the following, replacing recipes.mydomain.com with your domain:

recipes.mydomain.com {
    reverse_proxy localhost:9000 # Port on which Mealie is accessible on the host
}

Important changes in .env:

Similar to Nginx, change BASE_URL in the .env file:

BASE_URL=https://recipes.mydomain.com

Restart Mealie:

cd ~/mealie
docker compose restart mealie

3. Activating Caddy Configuration

sudo systemctl enable caddy
sudo systemctl restart caddy

Caddy will automatically obtain and configure an SSL certificate for your domain. Mealie will now be accessible at https://recipes.mydomain.com.

You have successfully set up a reverse proxy and HTTPS for Mealie. Your service is now accessible via a secure connection through your domain name.

Mealie Backup and Update

Regular backups and timely updates are fundamental for the reliable operation of any self-hosted application, including Mealie on a server. Do not neglect these steps to avoid data loss and ensure the security of your installation.

Backing Up Mealie

Your Mealie data consists of two main parts: the PostgreSQL database and files (images, configuration) stored in the data directory. For a complete backup, both parts must be saved.

1. Stopping Mealie (recommended for consistency)

cd ~/mealie
docker compose stop mealie

Stopping only the Mealie container will allow the database to continue running, but will halt write operations to the database from Mealie, ensuring data consistency when creating a dump.

2. Creating a PostgreSQL Database Dump

Use the pg_dump command from the PostgreSQL container:

docker exec mealie_db pg_dump -U mealie -Fc mealie > ~/mealie_backup/mealie_db_$(date +%Y%m%d%H%M%S).bak

Where:

• mealie_db – the name of the database container.
• -U mealie – the database user.
• -Fc mealie – dump format (custom, compressed) and database name.
• > ~/mealie_backup/mealie_db_$(date +%Y%m%d%H%M%S).bak – redirects output to a timestamped file in the ~/mealie_backup directory. Ensure this directory exists: mkdir -p ~/mealie_backup.

3. Copying Mealie Files

Copy the Mealie data directory. Since we mounted the ./data volume, all files are located in ~/mealie/data on the host.

cp -R ~/mealie/data ~/mealie_backup/mealie_data_$(date +%Y%m%d%H%M%S)

4. Starting Mealie

cd ~/mealie
docker compose start mealie

5. Automating Backups with Cron

You can create a script and configure Cron to automate backups. Create the file backup_mealie.sh:

nano ~/backup_mealie.sh

Script content:

#!/bin/bash

BACKUP_DIR="/home/$USER/mealie_backup"
MEALIE_DIR="/home/$USER/mealie"
TIMESTAMP=$(date +%Y%m%d%H%M%S)

mkdir -p "$BACKUP_DIR"

echo "Stopping Mealie container..."
docker compose -f "$MEALIE_DIR/docker-compose.yml" stop mealie

echo "Dumping PostgreSQL database..."
docker exec mealie_db pg_dump -U mealie -Fc mealie > "$BACKUP_DIR/mealie_db_$TIMESTAMP.bak"

echo "Copying Mealie data files..."
cp -R "$MEALIE_DIR/data" "$BACKUP_DIR/mealie_data_$TIMESTAMP"

echo "Starting Mealie container..."
docker compose -f "$MEALIE_DIR/docker-compose.yml" start mealie

echo "Cleaning old backups (keeping last 7 days)..."
find "$BACKUP_DIR" -type f -name "mealie_db_*.bak" -mtime +7 -delete
find "$BACKUP_DIR" -type d -name "mealie_data_*" -mtime +7 -exec rm -rf {} +

echo "Backup completed: $TIMESTAMP"

Make the script executable:

chmod +x ~/backup_mealie.sh

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

crontab -e

Add the line:

0 3 * * * /home/$USER/backup_mealie.sh >> /var/log/mealie_backup.log 2>&1

For more advanced backup solutions, including encryption and remote storage, we recommend checking out our article on Restic on a VPS: Installation, Configuration, and Maintenance.

Restoring Mealie from Backup

To restore, you will need to stop Mealie, restore the database and files, then start Mealie.

1. Stop Mealie:

   cd ~/mealie
   docker compose down

2. Delete current data (be careful!):

   rm -rf ~/mealie/data
   rm -rf ~/mealie/db-data

3. Restore data files:

   cp -R ~/mealie_backup/mealie_data_YYYYMMDDHHMMSS ~/mealie/data

   Replace YYYYMMDDHHMMSS with the timestamp of the desired backup.

4. Create empty directories for the database (if they were deleted):

   mkdir -p ~/mealie/db-data

5. Start the database container (without Mealie) so it can initialize:

   docker compose -f ~/mealie/docker-compose.yml up -d db

   Wait for the mealie_db container to fully start.

6. Restore the database from the dump:

   docker exec -i mealie_db pg_restore -U mealie -d mealie < ~/mealie_backup/mealie_db_YYYYMMDDHHMMSS.bak

   Replace YYYYMMDDHHMMSS with the timestamp of the desired backup.

7. Start Mealie:

   docker compose -f ~/mealie/docker-compose.yml up -d

Updating Mealie

Updating Mealie Docker involves updating Docker images and restarting containers.

1. Navigate to the Mealie directory:

   cd ~/mealie

2. Stop the containers:

   docker compose down

3. Pull new images:

   docker compose pull

   This will download the latest versions of Mealie and PostgreSQL images.

4. Start the containers again:

   docker compose up -d

   Mealie will automatically perform database migrations if necessary.

5. Clean up old Docker images (optional):

   docker image prune -f

It is recommended to check official Mealie releases on GitHub, as sometimes additional steps may be required during updates (e.g., changes to the .env or docker-compose.yml file).

Which VPS to Choose for Mealie: Configuration Recommendations

Choosing the optimal VPS for Mealie depends on your needs: number of users, volume of recipes, and frequency of use. Let's consider different scenarios and their corresponding VPS configurations available on Valebyte.com.

VPS Configuration Comparison Table for Mealie

Usage Scenario	CPU (vCores)	RAM (GB)	Disk (NVMe SSD, GB)	Approx. Cost/Month (Valebyte.com)	Notes
Personal Use / Small Family (1-3 users, up to 1000 recipes)	1	1-2	25	from $5 - $8	Ideal for getting started. Ensures fast operation.
Active Family / Small Community (3-10 users, 1000-5000+ recipes)	2	2-4	50	from $10 - $15	Good balance of performance and cost. Recommended for most users.
Culinary Blog / Large Community (10+ users, 5000+ recipes)	4	4-8	100+	from $20 - $35+	For high loads, a large number of images, and simultaneous requests. Allows running other services.
Development / Testing Mealie	1	1	25	from $5	Minimum configuration, sufficient for experiments.

Important Aspects When Choosing a VPS

1. Disk Type: NVMe SSD. This is critically important for Mealie's responsiveness. Database operations and image loading will be significantly faster on NVMe compared to regular SSDs or HDDs. Valebyte.com offers VPS with NVMe disks by default.
2. Server Location: Choose a data center that is geographically close to your primary users. This minimizes latency and improves access speed to Mealie.
3. Guaranteed Resources: Ensure your VPS provides guaranteed resources (dedicated resources), not "burstable" or "shared" CPU/RAM, which can be overloaded by other users on the same physical server.
4. Scalability: Choose a provider that allows you to easily increase (or decrease) your VPS resources as your needs change. Valebyte.com offers flexible plans and the option to upgrade at any time.
5. Operating System: Ubuntu Server LTS or Debian Stable are the most recommended OS for hosting Docker applications. They are well-documented and have a broad support community.
6. Network Bandwidth: While Mealie doesn't require massive bandwidth, a stable 1 Gbit/s connection will be an advantage, especially if you plan to upload many images or have multiple users.
7. Technical Support: High-quality and responsive technical support from your hosting provider can be invaluable, especially if you encounter infrastructure-level issues.

To monitor your VPS resource usage and optimize its performance, we recommend checking out our article on Netdata on a VPS: Installation, Configuration, and Maintenance. This will help you understand which VPS configuration truly suits your Mealie workload.

Starting with the recommended configuration (2 vCPU, 2-4 GB RAM, 50 GB NVMe SSD) will give you an excellent balance of performance and cost for most Mealie usage scenarios. If you plan to use your VPS for other self-hosted applications, such as Home Assistant on a VPS or VPS server for 1C, always choose a plan with extra resources.

Conclusion

Installing Mealie on a VPS via Docker Compose is a reliable and flexible solution for creating your own recipe management platform, providing full control over your data and high performance. Choosing the right VPS configuration, regular backups, and timely updates ensure the stable and secure operation of your service. Valebyte.com provides optimal VPS plans with NVMe disks, ideally suited for hosting Mealie and your other self-hosted projects.