Mealie on Google Cloud Run
Mealie is an open-source, self-hosted recipe manager and meal planner with a FastAPI backend and a Vue frontend, offering automatic recipe import by URL alongside a manual UI editor. This module deploys Mealie on Cloud Run v2 on top of the App_CloudRun foundation, which provisions and manages the shared Google Cloud infrastructure.
This guide focuses on the cloud services Mealie uses and how to explore and operate them from the Google Cloud Console and the command line. For the mechanics common to every Cloud Run application — service identity, ingress and load balancing, scaling and concurrency, CI/CD, Cloud Armor, IAP, Binary Authorization, VPC Service Controls, backups, and the deployment lifecycle — refer to the App_CloudRun foundation guide rather than repeating them here.
What Mealie costs on RAD, and how that compares
Mealie on RAD's Cloud Run module costs about US$68 a month in your own project, with no per-household subscription. RAD charges 40 credits once per deployment in your own project (36 credits, 10% lower, in a project RAD manages), plus build time. Mealie also deploys on GKE Autopilot for about US$91 a month — see the GKE guide if you need it to run there instead. If you only need it occasionally, a RAD-managed project can be deleted and restored within 30 days for a few credits, so that monthly figure becomes a few dollars instead — see Pause it for free, below.
What you pay on RAD
| In a Google Cloud project you own | In a project RAD manages for you | |
|---|---|---|
| Module fee, once per deployment | 40 credits (US$4.00 at the top-up price) | 36 credits (10% lower) |
| Build time | A few credits per build | The same |
| Google Cloud running cost | Billed by Google to your own billing account, about US$68 a month for the default configuration (table below) | Metered hourly in credits; RAD publishes 26 credits a day, about 780 a month (about US$78.00 at the top-up price, less on a plan) |
| Who owns what | You own the project and its billing; RAD deploys and updates it | RAD owns the project, with guardrails, quotas and budget alerts; you get console access, and a minimum purchased balance is held in reserve |
10 credits cost US$1 on a one-off top-up, and less on a monthly plan. In a project RAD manages, the database, file server and network are shared by every application in the project, so a second application does not add a second database.
Default running cost in your own project (us-central1, Google list prices):
| Resource (module default) | Per month |
|---|---|
| Cloud Run, 1x vCPU / 0.5 GiB (scaleToZero) | US$11 |
| Cloud SQL for PostgreSQL, 1 vCPU / 3.75 GB, zonal, 10 GB SSD | US$51 |
| Cloud NAT and networking | US$5 |
| Cloud Storage (add-ons, backups) | US$1 |
| Total | about US$68 |
How it compares
- Plan to Eat, a hosted recipe manager and meal planner, costs US$5.95 a month (US$49 a year, about US$4.08 a month billed annually) and covers one household across web, iPhone and Android.
- RAD's Mealie module costs about US$68 a month in your own project — more than a single Plan to Eat subscription in cash terms for one household. The case for RAD here is owning your recipe data outright with no subscription lock-in and full API access, and it stops making sense in isolation once a household just wants a cheap meal planner — it fits best alongside other self-hosted apps already running in the same project.
- Self-managed comparison: at 1 vCPU / 0.5 GiB with a Postgres database, a Hetzner CPX22 or DigitalOcean 2 vCPU/4 GB droplet (~US$24/month) is in range, but you run Postgres, backups and upgrades yourself.
Pause it for free: delete a RAD-managed project, restore it when you need it
If Mealie runs in a project RAD manages for you, you have a second option that goes well beyond scaling to zero: delete the whole project, and restore it within 30 days for close to nothing. This suits Mealie you only need occasionally — evaluating it, a demo environment, a seasonal or intermittent workload — far better than running it continuously.
- How it works. Deleting a RAD-managed project unlinks its billing first, then asks Google to delete the project. Google does not remove the project immediately: it keeps it, recoverable, for 30 days. Because billing is already unlinked, nothing is charged while it waits. Unlike deleting one module, this does not tear down the database, any VM or the compute resource one by one — the whole project, and everything in it, simply stops.
- Restoring costs a few credits, not a rebuild. Within 30 days, the project's owner can restore it. RAD asks Google to undelete the project and reattaches its billing account, then asks you to run Update on each deployment to confirm everything came back. Because nothing was individually destroyed, that Update finds the same resources already there — it is a check, not a rebuild, and an Update never charges the module fee again. For Mealie behind Services_GCP (a Postgres database) and Project_GCP, that is roughly a handful of credits (under US$1) in total, against the about 45 credits (US$4.50) a full redeploy costs.
- So a month of occasional use can cost a few dollars, not US$68. Deploy Mealie, use it for a while, delete the project. Restore it next time you need it, confirm with Update, and delete it again when you're done. You pay only for the module fee once, the builds, and whatever time it was actually live.
- What this needs. You must own the project (not one RAD only manages billing for), and you restore it yourself within the 30 days — after that, Google deletes it for good. Restoring is admitted like creating a new project: your purchased credit balance must still clear the tier's floor (100 credits for the sandbox tier most evaluation use fits). Google says most services are fully working again within 36 hours of a restore.
- One real gap: nightly backups do not survive. Backups and other generated files are written to a bucket inside the project, and that bucket is not protected by Cloud Storage's soft-delete, so it is very likely gone as soon as you delete the project — even though the project itself is recoverable for 30 days. If you have customised Mealie and want to keep that work, copy a backup out (to Google Drive, or a bucket outside the project) before you delete. For a default installation with nothing irreplaceable in it, this does not matter.
Pay only while you use it, the other way: delete and redeploy
The option above only applies to a RAD-managed project; in your own project, or once the 30-day window has passed, the way to stop paying is to delete the deployment and deploy it again when you need it.
- What a redeploy costs. The module fee again, plus the builds — roughly 45 credits (US$4.50) in total. Deleting saves money only once Mealie would otherwise sit unused long enough to clear that redeploy cost against its own running cost — about 2 days or more, both in your own project (about US$2.26 a day) and in a RAD-managed one (26 credits a day).
- Most of the running cost is usually shared. For Mealie that is the database. They stop only when nothing else in the project uses them, so deleting this app while something else shares the project saves only this app's own compute part.
- Keep your data first. Nightly backups go to a bucket inside the deployment and are deleted with it, so copy the latest backup out before deleting if you want to keep it.
Lab sessions and Managed Environments
- Lab sessions, for training. A trainer runs a session for a class. Each participant gets the app in their own Google Cloud project for 15 minutes to 24 hours, within an allowance the trainer sets. Either the trainer funds every place, or each participant pays for their own. Everything is deleted when the session ends and unused credits go back to the trainer.
- Managed Environments, for consultancies. A partner runs the app for a client from a ring-fenced wallet it funds, and settles with the client directly. If the wallet runs low, billing pauses and the data is kept, so nobody receives an unexpected charge. At the end the partner hands the project over and the deployments become the client's own.
Credits can be bought in more than 20 currencies, including XAF, XOF, NGN, GHS, KES and ZAR, by card, bank transfer or mobile money.
Sources (8 October 2026): Google Cloud list prices from the Cloud Billing Catalog API; RAD fees and the daily-credit estimate from radmodules.dev/pricing; Delete and restore projects for the pause/restore mechanics and what it says about Cloud Storage objects without soft delete; Plan to Eat. Prices change; check each source before relying on a figure.
1. Overview
Mealie runs as a single FastAPI/Vue container on Cloud Run v2. The deployment wires together a small, focused set of Google Cloud services:
| Capability | Google Cloud service | Notes |
|---|---|---|
| Compute | Cloud Run v2 | FastAPI service, 1 vCPU / 512 MiB by default, scale-to-zero |
| Database | Cloud SQL for PostgreSQL 15 | Mealie reads discrete POSTGRES_* env vars, not a constructed DSN |
| Object storage | Cloud Storage | A data bucket is created for recipe images and auto-mounted at /app/data |
| Cache & queue | none | Mealie has no Redis or queue dependency |
| Secrets | Secret Manager | Database password only — Mealie has no env-configurable admin credential |
| Ingress | Cloud Run URL | Default run.app URL; optional external HTTPS load balancer + custom domain |
Sensible defaults worth knowing up front:
- PostgreSQL 15 is the standardized engine.
Mealie_Commonfixesdatabase_type = "POSTGRES_15"and setsDB_ENGINE=postgresexplicitly — Mealie defaults to embedded SQLite otherwise. - No custom container build. Mealie's discrete Postgres env vars need no
DSN construction, so the official prebuilt image
(
ghcr.io/mealie-recipes/mealie) is used directly. - Default admin account, not first-registration — and it is NOT
configurable. Unlike some apps in this catalogue, Mealie does not let the
first visitor self-register as admin, and unlike earlier Mealie versions
its initial credential can no longer be set via environment variables (the
underlying settings are private, non-env-bindable fields as of v3.x — see
the Common guide for the source-level detail). Every
deployment boots the same well-known account:
changeme@example.com/MyPassword. Log in immediately after first deploy and change both the password and, ideally, the admin email — Mealie forces a password reset on first login, which is the real security boundary here, not secrecy of the initial credential. - Recipe images are persisted by default.
Mealie_Commondeclares agcs_volumesentry mounting thedataGCS bucket at Mealie's/app/datapath, so uploaded recipe images survive a revision restart. Recipe text data is unaffected either way (stored in PostgreSQL). - Request-based billing by default.
cpu_always_allocated = false,min_instance_count = 0— Mealie's URL-import scraping runs synchronously within the triggering request, not as a background job.
2. Google Cloud Services & How to Explore Them
All commands assume PROJECT and REGION are set. Service and resource names
are reported in the deployment Outputs.
A. Cloud Run — the Mealie service
- Console: Cloud Run → select the service for revisions, traffic, logs, and metrics.
- CLI:
gcloud run services list --project "$PROJECT" --region "$REGION"
gcloud run services describe <service-name> --project "$PROJECT" --region "$REGION"
See App_CloudRun for scaling, concurrency, and traffic splitting.
B. Cloud SQL for PostgreSQL 15
Mealie stores all recipes, meal plans, and user data in a managed Cloud SQL for PostgreSQL 15 instance, connected privately via the Cloud SQL Auth Proxy over a Unix socket. On first deploy, an initialization Job creates the application database and user.
- Console: SQL → select the instance for connections, backups, flags, metrics.
- CLI:
gcloud sql instances list --project "$PROJECT"
gcloud sql connect <instance-name> --user=<db-user> --database=<db-name> --project "$PROJECT"
C. Cloud Storage
A data bucket is provisioned automatically for recipe images, and is mounted
into the container at /app/data by default.
- CLI:
gcloud storage buckets list --project "$PROJECT" --filter="name~mealie"
D. Secret Manager
- CLI:
gcloud secrets list --project "$PROJECT" --filter="name~mealie"
gcloud secrets versions access latest --secret=<secret-name> --project "$PROJECT"
E. Networking & ingress
- CLI:
gcloud run services describe <service-name> --region "$REGION" --format='value(status.url)'
F. Cloud Logging & Monitoring
- CLI:
gcloud run services logs read <service-name> --project "$PROJECT" --region "$REGION" --limit 50
3. Mealie Application Behaviour
- First-deploy database setup. An initialization Job runs
create-db-and-user.shusingpostgres:15-alpine, idempotently creating the application role and database. - Schema migrations on start. Mealie applies its own internal migrations automatically on every startup.
- Fixed default admin credential — not configurable. Mealie creates
changeme@example.com/MyPasswordon first database initialisation. This is a hardcoded upstream default (no env var overrides it as of v3.x), not a generated secret — a password reset is forced on first login, and operators must complete it immediately after deploy. - Health path. Startup and liveness probes target
/api/app/about— Mealie's real, unauthenticated info endpoint. - Inspect job execution:
gcloud run jobs executions list --job <job-name> --project "$PROJECT" --region "$REGION"
4. Configuration Variables
Variables are grouped exactly as they appear on the deployment platform. Only settings specific to or notable for Mealie are listed; every other input is inherited from App_CloudRun with its standard behaviour.
Group 3 — Application Identity
| Variable | Default | Description |
|---|---|---|
application_name | mealie | Base name for resources. |
application_version | latest | Mealie publishes a genuine latest tag — no remapping needed. |
Group 4 — Runtime & Scaling
| Variable | Default | Description |
|---|---|---|
container_image_source | prebuilt | No custom build needed — discrete Postgres env vars require no DSN construction. |
container_port | 9000 | Mealie's native default port. |
cpu_always_allocated | false | Request-based billing. |
min_instance_count / max_instance_count | 0 / 1 | Scale-to-zero default. |
Group 11 — Storage & Filesystem
| Variable | Default | Description |
|---|---|---|
storage_buckets | one data bucket | Created and auto-mounted at /app/data for recipe images. |
gcs_volumes | [] | Empty means "use Mealie_Common's own /app/data mount"; a non-empty list replaces it. |
Group 12 — Database Backend
| Variable | Default | Description |
|---|---|---|
database_type | POSTGRES_15 | Fixed by Mealie_Common. |
db_host_env_var_name | POSTGRES_SERVER | Aliases the platform DB_HOST onto Mealie's expected name. |
db_user_env_var_name | POSTGRES_USER | Aliases DB_USER. |
db_password_env_var_name | POSTGRES_PASSWORD | Aliases DB_PASSWORD. |
db_name_env_var_name | POSTGRES_DB | Aliases DB_NAME. |
db_port_env_var_name | POSTGRES_PORT | Aliases DB_PORT. |
Group 14 — Observability & Health
| Variable | Default | Description |
|---|---|---|
startup_probe / liveness_probe | HTTP /api/app/about 30s delay | Probes target Mealie's real info endpoint. |
5. Outputs
| Output | Description |
|---|---|
service_name / service_url | Cloud Run service name and default run.app URL. |
database_instance_name / database_name / database_user / database_host / database_port | Cloud SQL connection details. |
storage_buckets | The data bucket for recipe images. |
deployment_id / tenant_id / resource_prefix | Naming identifiers. |
project_id / project_number | Project identifiers. |
6. Configuration Pitfalls & Sensible Defaults
Risk: Critical (data loss / outage / security) — High (service degraded) — Medium (cost or partial degradation) — Low (minor).
| Setting | Sensible value | Risk | Consequence if wrong |
|---|---|---|---|
application_database_name / application_database_user | Set once | Critical | Immutable after first deploy; renaming recreates the DB/user and destroys all data. |
container_image_source | prebuilt (default) | High | "custom" triggers an unnecessary Cloud Build with no Dockerfile in this module — the build fails. |
Default admin credential (changeme@example.com / MyPassword) | Log in and change it immediately after first deploy | Critical | This is a fixed, publicly documented upstream default — not a generated secret — as soon as the DB initialises, anyone who knows Mealie's default credential can log in until you complete the forced first-login password reset. |
gcs_volumes for recipe images | Leave empty (use the module's own /app/data mount) | Medium | Mealie_Common already mounts the data bucket at /app/data. Supplying a non-empty gcs_volumes list replaces that mount entirely — if the replacement does not also cover /app/data, uploaded recipe images fall back to Cloud Run's ephemeral filesystem and do not survive a revision restart. Recipe text is unaffected. |
db_*_env_var_name variables | Leave at their Mealie-specific defaults | Critical | Changing/clearing these breaks Mealie's Postgres connection entirely — it reads POSTGRES_*, not DB_*. |
For the foundation behaviour referenced throughout — service identity, scaling and concurrency, ingress and load balancing, CI/CD, Cloud Armor, IAP, Binary Authorization, VPC-SC, backups, and image mirroring — see App_CloudRun. Mealie-specific application configuration shared with the GKE variant is described in Mealie_Common.
Related guides
- Hands-on lab: Mealie on Cloud Run — deploy it step by step, with the console screens and commands at each stage.
- Mealie on GKE Autopilot — the same application on Kubernetes, for when you need the other deployment target.
- Mealie Common — Shared Application Configuration — the configuration shared by both deployment targets.
Need RAD to do something it does not do yet? Request it on the roadmap, or vote on what is already there.