# Self-hosted search done right: 2server's Meilisearch template

> A shared Meilisearch on your own VM, independent of Soot. Four defaults in 2server's template — an indexing RAM cap, an unprivileged read-only container, per-index client keys and an authenticated readiness probe — remove the two ways self-hosted search usually breaks.

- URL: https://2found.dev/blog/self-hosted-meilisearch-with-2server-en/
- Published: 2026-11-10T09:01:45.045Z
- Updated: 2026-11-10T09:01:45.045Z
- Language: en

---

Self-hosted full-text search tends to fail in two quiet ways. Your apps each carry a copy of the master key, so when one leaks, every index leaks. And one big indexing run can eat the machine's RAM until the OOM killer picks a victim — usually at the worst possible hour.

2server's `meilisearch` template attacks both with resource limits and key isolation baked into the defaults: one shared Meilisearch on your own VM, **independent of Soot** — Soot neither runs through it nor needs it running.

Here is what the template does. Commands and variables live in the [2server meilisearch docs](https://2found.dev/docs/2server/meilisearch/).

## Indexing gets a ceiling, not the whole machine

A first index build or a reindex after a schema change is when a search engine is hungriest for memory. On a VM with headroom that's a slowdown. On a VM running your actual app, it can push the kernel to kill a process — and the process isn't guaranteed to be Meilisearch.

The template puts two fences around it:

- **Indexing memory capped at 50% of the container's RAM.** The other half is reserved for the engine serving queries and the container's OS — a stop line before the OOM killer ever gets involved.
- **Tmp indexing writes to disk, not RAM.** The temporary files an index build produces — the part that eats memory fastest — go to disk instead. Disk is slower, but a full disk is an error you can see; exhausted RAM is a dead container.

On the same VM, everything else survives the biggest index build you'll ever run — the build is just slower, not fatal.

## An unprivileged, read-only container that publishes no ports

The container runs as the unprivileged user `65532:65532`, and its root filesystem is mounted **read-only**: anything it must write has to be a separately mounted volume; everything else is off-limits. One more default: **no ports are published to the host** — traffic reaches Meilisearch over the internal network on that VM.

For a service that only exists to serve your app, these are the right defaults: nothing exposed means no question about who is scanning your port, and a read-only rootfs shrinks what an attacker can change if the process is ever compromised.

## The master key never leaves the infrastructure layer

This is where self-hosted search most often goes wrong operationally. A Meilisearch master key can do anything — create, delete, read every index. If each app holds a copy "for convenience", one leak is a total leak.

In the template the master key stays **isolated at the infrastructure layer** and is never handed to an app. Instead, 2server **issues a separate client API key per product index**: your app holds a key scoped to exactly the index it needs. A leaked app key exposes one index; the master key stays somewhere the app can't read.

## Readiness is authenticated before a release

A search container that is "up" can still be unready: indexes not loaded, or busy warming up. The template's readiness probe **checks the authenticated `/indexes` endpoint** — not just an open port. Only when the probe passes does the new version get released. A replacement takes traffic only once it proves it answers the real protected API, not merely that a process exists.

## What the template does not do

The boundaries matter as much as the features:

- **No automatic backup, no automatic Meilisearch version migration.** When you upgrade, take a manual snapshot first. Treat upgrades as a prepared operation, not a routine restart.
- **Not a Soot dependency.** This engine runs for your apps, on your VM, separate from Soot. Soot's data-pool keeps its metadata in **PostgreSQL**, not Meilisearch — don't read that backwards.

## Next step

If your app needs search on a VM that already runs 2server: read the [meilisearch template docs](https://2found.dev/docs/2server/meilisearch/), deploy it as the shared engine, issue one client key per index — and keep the master key where apps can never reach it. Before your first upgrade, take the snapshot yourself; that's the one job the template hands back to you.
