Skip to content

Sizing Guide

This guide sizes the Muppy control plane of a high-availability deployment: the two sites that run Muppy and its PostgreSQL database, and the Muppy Bootstrap that manages them. The servers that host your App Servers are sized with your applications, outside this guide.

The guide holds what is true on any infrastructure. A page per cloud provider maps it onto that provider's machines, disks and network:

Muppy runs on entry-level machines

Muppy runs in production on entry-level virtual servers that cost less than €20 a month: some of our customers run it on an OVH VPS-3 (6 vCPU, 12 GB), listed at €10.40 a month excluding VAT (price as of 17 November 2026). From one such server, Muppy manages several LXD and Kubernetes clusters, with dozens of App Servers and Kubernetes Releases under monitoring.

Most of its load is a fixed base: health checks every minute, replication monitoring, scheduled jobs. Two resources grow with the estate:

  • memory, with the number of tasks run at once: each Muppy process holds about 250 MB;
  • the database, by about 100 MB per managed host, App Server or Release.

Muppy scales both ways:

  • vertically: a larger machine, tier by tier (see Choosing a tier);
  • horizontally: several Muppy instances behind a Traefik load balancer, sharing a dedicated PostgreSQL database.

Architecture

The topology is the one drawn in Data Flows, with one site per availability zone or per region.

flowchart TB
    U["Users"] --> LB["Load balancer<br/>Cloudflare recommended"]
    subgraph A["Site A: primary"]
        TA["Traefik"] --> MA["Muppy<br/>LXC container"] --> PA[("PostgreSQL<br/>primary")]
    end
    subgraph B["Site B: standby"]
        TB["Traefik"] --> MB["Muppy<br/>LXC container"] --> PB[("PostgreSQL<br/>standby, read-only")]
    end
    BS["Muppy Bootstrap<br/>third location, or site B"]
    LB -- "traffic" --> TA
    LB -. "after a failover" .-> TB
    PA -- "streaming replication, TLS" --> PB
    BS -. "SSH, health checks, failover" .-> TA
    BS -. "SSH, health checks, failover" .-> TB
Component Role
Site A Traefik, Muppy in an LXC container and the primary PostgreSQL cluster, on one machine. Serves the users and manages your estate.
Site B The same stack. Its database is a read-only copy of site A's, kept current by streaming replication. Takes over at a failover.
Muppy Bootstrap A separate, small Muppy instance that manages both sites as its own hosts: installation, configuration, Muppy upgrades, health checks every minute, failover.
Load balancer Carries Muppy's public name and sends the traffic to the primary site only.

Muppy stores its attachments in PostgreSQL, so replication carries the whole state of the application.

Where the Muppy Bootstrap goes

A third location is best: a third zone or region, or another provider. Without one, the Bootstrap goes on site B's side:

  • if site A fails, the Bootstrap is still there to drive the failover to site B;
  • if site B fails, site A keeps serving and nothing has to move; the Bootstrap is rebuilt from its backup.

The Bootstrap is not replicated: its database is backed up like the others (see Backups).

How a failover happens

  1. Each site publishes /inouk_health_check. The site whose database is primary answers cluster_is_primary, the other one cluster_is_standby. Both answer HTTP 200.
  2. The load balancer sends the traffic only to the site that answers cluster_is_primary.
  3. A failover promotes site B's database to primary: by hand, with Set as Primary on the Replicated Cluster Set, from the Bootstrap; or automatically, when the Bootstrap's health checks see that site A is lost. The answers flip and the traffic follows, with no DNS change.
  4. Replication is asynchronous: an unplanned failover loses the transactions committed on site A that site B had not received yet.
  5. After an unplanned failover, the former primary is rebuilt as a standby of the new primary before it serves again, and stays out of the load balancer until then. Restarted on its own, it would answer cluster_is_primary, and the load balancer, which prefers site A, would send the traffic back to it.

Choosing a tier

Count what Muppy will manage in twelve months: the App Servers it runs on LXD, and the LXD and Kubernetes clusters it operates. Pick the first tier that holds both; a production deployment starts at tier S. Both sites always have the same size, since site B carries the whole load after a failover.

Tier LXD App Servers LXD / K8s Clusters Each site PostgreSQL data disk Task workers
XS up to 20 up to 5 Evaluation only: one machine, 2 vCPU, 8 GiB; Muppy and PostgreSQL together, no high availability 64 GiB, 3,000 IOPS, 125 MB/s 4
S up to 100 up to 10 4 vCPU, 16 GiB; Muppy and PostgreSQL on one machine 128 GiB, 3,000 IOPS, 125 MB/s 7
M up to 300 up to 25 8 vCPU, 32 GiB; Muppy and PostgreSQL on one machine 256 GiB, 3,000 IOPS, 125 MB/s 12
L up to 800 up to 60 Muppy: 8 vCPU, 32 GiB
PostgreSQL: its own machine, 8 vCPU, 64 GiB
1 TiB, 5,000 IOPS, 200 MB/s 20
XL up to 2,000 up to 150 Muppy: 16 vCPU, 64 GiB
PostgreSQL: its own machine, 16 vCPU, 128 GiB
2 TiB, 8,000 IOPS, 300 MB/s 32
Above more than 2,000 more than 150 Contact the oursbl.eu teams

The Muppy Bootstrap takes 2 vCPU and 8 GiB at every tier from S, with its own PostgreSQL on a 128 GiB disk: it manages the two sites and nothing else.

  • Tier XS is for evaluating Muppy on a few hosts. It runs outside high availability: no standby, no Bootstrap, no failover.
  • Tier S is the size of the entry-level instances Muppy runs on in production.
  • Each tier up adds the two resources that grow: memory for more task workers, and disk for the database.
  • The disk's IOPS sit far above the need: Muppy's PostgreSQL uses a few hundred IOPS at most, and 13 KB/s of WAL.
  • Beyond one machine, Muppy scales out: from tier L, PostgreSQL has a machine of its own, and more Muppy instances can share it behind a Traefik load balancer.

A deployment counts one machine at tier XS, three at tiers S and M (site A, site B, the Bootstrap), and five at tiers L and XL.

Indicative figures

These tiers are starting points, to adjust to the reality of the workloads Muppy manages. The load of a deployment depends on:

  • the number of health checks, their frequency and their timeouts: a target that does not answer holds a task worker for its whole timeout;
  • PostgreSQL replication;
  • how long histories are kept: health check results, task journals;
  • the density of the hosts: how many App Servers share one host.

Today, health checks set the first limit: the checks of each minute run one after another, and a target that does not answer holds a task worker for its whole timeout. An improvement is being designed to run them in parallel.

Machines

The prerequisites of every Muppy Enterprise server apply. In addition:

  • Operating system: Ubuntu Server 24.04 LTS on every machine. Muppy installs and runs PostgreSQL 16.
  • Containers only: Muppy runs in an LXC container, through the LXD snap. No nested virtualization is needed.
  • No burstable instances (instances that run on CPU credits): the health checks of every minute keep a constant base load that drains the credits.
  • Disks:
    • system: 64 GiB SSD;
    • PostgreSQL data: a disk of its own, with the size, IOPS and throughput of the tier;
    • the Muppy container (LXD storage pool): 128 GiB SSD;
    • PostgreSQL never lives on an ephemeral or temporary disk, which a redeployment erases;
    • a disk's IOPS stay within the IOPS limit of the machine it is attached to: the excess is not served.

Network

  • A private link between the two sites and the Bootstrap (one private network, or a peering): replication and administration never cross the Internet.
  • A static public IP address per site, which the load balancer uses as its origin.
  • Firewall rules that allow these flows, and only these:
From → To Port Purpose
Load balancer → sites A and B TCP 443 User traffic and the health monitor. Allow the load balancer's published address ranges only
Site B ⇄ site A TCP 5432, TLS PostgreSQL replication, opened by the standby. Its direction reverses after a failover: allow both ways
Bootstrap → sites A and B TCP 22, key authentication Installation, configuration, upgrades, failover
Bootstrap → sites A and B TCP 9100, 9187 Health checks, every minute
Sites A and B, Bootstrap → Internet TCP 443; TCP 587 or 465 Git, SMTP relay, S3 storage, alert channel, muppy.io services, usage telemetry (host counts, no application data)
Muppy → your managed servers TCP 22, 5432, 6443, 8443, 16443, 9100, 9187 Managing your App Servers, clusters and databases
oursbl.eu support → Bootstrap TCP 22 At your request only, through a temporary firewall rule that expires on its own

The complete list of flows, with their trust boundaries, is in Data Flows.

Load balancer

The load balancer tells the primary from the standby by the body of the answer to /inouk_health_check, since both sites answer HTTP 200. A load balancer that judges an origin by its status code only sees two healthy sites, and sends users to the standby, whose database refuses every write.

Cloudflare Load Balancing, a paid add-on of a Cloudflare account, matches the body. The oursbl.eu teams supply its setup:

Setting Value
DNS record Muppy's public name, proxied, served by the load balancer
Pools Two pools of one origin each: site A's public address, and site B's. Host header: Muppy's public name
Monitor HTTPS, GET /inouk_health_check, expected code 200, expected body cluster_is_primary, interval 60 s or less as the plan allows, 2 retries
Traffic steering Off: default pools in the order A then B, fallback pool B
SSL/TLS Full (strict): each site presents a valid certificate, managed by Muppy

Backups

  • Muppy backs up its PostgreSQL databases to an S3-compatible object storage: the storage must speak the S3 API.
  • The storage sits outside both sites, preferably with another provider, so that an incident on one site, or in one region, leaves the backups intact.
  • The Bootstrap backs up its own database to the same storage.
  • The retention is set at installation.

Operations

  • Growing. Resize site B first, fail over to it, then resize the former primary: the only interruption is the failover's. Moving from tier M to tier L adds a PostgreSQL machine to each site and moves the database onto it, an operation planned with the oursbl.eu teams.
  • Muppy upgrades. The Bootstrap deploys them on both sites: the database is upgraded through the primary, the code is deployed everywhere.
  • Monitoring. The Bootstrap probes both sites every minute, and alerts on your channel (Teams, Slack or Pushover) and by email.
  • Traffic between sites. Replication sends the primary's WAL to the standby continuously: about 1 GB a day, a few tens of GB a month. Even billed between regions, it is a small line on the bill.
  • Support access. oursbl.eu support reaches the Bootstrap only at your request, through a temporary firewall rule that expires on its own.

Responsibilities

You provide:

  • the machines, their disks, the private network between them and the firewall rules above;
  • the load balancer: the Cloudflare zone of Muppy's public name, with Load Balancing;
  • an S3-compatible object storage for the backups;
  • an SMTP relay and an alert channel;
  • access to your Git provider (GitLab, GitHub or Azure DevOps).

The oursbl.eu teams install the Bootstrap server, then use it to install Muppy on both sites, and set up the PostgreSQL replication, the failover, the health checks, the alerts, the backups and the load balancer's configuration.

Before deploying

The answers that fix a deployment:

  1. The number of LXD App Servers, and of LXD and Kubernetes clusters, today and in twelve months: it sets the tier.
  2. The two sites, zones or regions, and the location of the Bootstrap.
  3. The load balancer: the Cloudflare zone of Muppy's public name, and its Load Balancing subscription.
  4. The S3-compatible storage for the backups, and the retention.
  5. The SMTP relay, the alert channel and the Git provider.
  6. The failover mode: manual or automatic.

The page of your cloud provider adds its own questions.