DocsDeploy & operate
Deploying
Run Sluurp on a server, with HTTPS in front, backups and upgrades.
In production, a Sluurp app is one binary, one app folder and one data folder on a machine you control. There’s no database server and no build step. To run it on a server, install the binary, create an admin and serve the app:
curl -fsSL https://raw.githubusercontent.com/SluurpHQ/releases/main/install.sh | sh
sluurp --dir /srv/sluurp/data superuser you@example.com
sluurp --dir /srv/sluurp/data serve --public /srv/sluurp/app --no-hot-reloadFeatures include:
- One-click starts on Render, Railway, Fly.io, DigitalOcean and Hetzner
- A Docker image, and a systemd unit for any Linux server
- Files on a disk of their own, or in an S3-compatible bucket
- Structured logs for Grafana, Splunk, Datadog and the ELK stack
- Incremental backups, copied offsite encrypted
- Upgrades by replacing the binary
In one click
Start from SluurpHQ/starter, a template with a small app and everything a host needs. Each option below keeps your data on a disk of its own, so it survives a redeploy. For commercial use, set your licence as SLUURP_LICENSE.
- Render: the template’s Deploy to Render button, with a 1 GB disk.
- Railway: a project from the template, plus a volume at
/data. - Fly.io:
fly launch, a volume nameddata, thenfly deploy. - DigitalOcean, Hetzner or any Ubuntu or Debian server: paste cloud-init.yaml as the server’s user data when you create it. Fill in your domain, the first admin and your licence first. On DigitalOcean that’s Create Droplet, Advanced options; on Hetzner Cloud it’s the Cloud config field. Sluurp runs as a service behind Caddy, with HTTPS.
Docker
docker run -d -p 8090:8090 -v sluurp-data:/data -v "$PWD/app:/app" ghcr.io/sluurphq/sluurpThe image serves the app in /app and keeps its data in /data. To ship your app inside it:
FROM ghcr.io/sluurphq/sluurp
COPY --chown=sluurp app /appOn the server
The commands at the top of this page install the binary, create an admin and serve the app:
--diris the data folder: one SQLite file per project. It’s the only folder you need to back up.superuserasks for the password, shown as stars. If you’d rather create the administrator in the browser, the server prints a one-time setup code in its log at start; the admin asks for it, since you aren’t on the server itself (The first administrator).--no-hot-reloadturns off watching files, which production doesn’t need.--publiccan also be the app’s repository URL: it’s cloned on first start and pulled on each restart.
By default, Sluurp listens on 127.0.0.1:8090, this machine only. To take connections from outside, use --addr 0.0.0.0:8090, or better, put a reverse proxy in front.
HTTPS
Sluurp serves plain HTTP, and a reverse proxy adds HTTPS. Caddy gets and renews certificates by itself:
app.example.com {
reverse_proxy 127.0.0.1:8090
}Realtime, sync and cursors use WebSockets, which Caddy proxies out of the box. With nginx, forward the Upgrade and Connection headers.
Behind a proxy, the logs, rate limits and the security log still see each visitor’s own address, not the proxy’s. Sluurp believes what a proxy on the same machine or network says about the client (X-Forwarded-For, Forwarded or X-Real-IP), and what Cloudflare’s edge says (CF-Connecting-IP). It ignores these headers when they come from anywhere else, so a visitor can’t hide behind a made-up address.
Bots that scan servers for paths like /.env, /wp-login.php or /actuator/env are shut out on their own. Sluurp answers those paths with 404 at once, before your app runs. A client that keeps asking for them is refused for 15 minutes, then twice as long each time it comes back. Visitors from your own machine or network are never shut out. The admin’s rate limits list who is shut out, with a button to let them in again, and a switch to turn this off.
Behind a CDN
A CDN such as Cloudflare may keep files in browsers for hours, whatever your server says. Sluurp makes sure a deploy still shows at once: every page links your app’s own stylesheets, scripts and pictures with their version, as in /site.css?v=3q4olbmgv0. The version changes when the file does, so the new address is fetched fresh, and a versioned address is cached for a year. There’s nothing to set up: it covers href, src, srcset, and an og:image on your own domain.
Running as a service
A systemd unit that starts Sluurp at boot and restarts it on failure:
[Unit]
Description=Sluurp
After=network.target
[Service]
ExecStart=/home/sluurp/.sluurp/bin/sluurp --dir /srv/sluurp/data serve --public /srv/sluurp/app --no-hot-reload
User=sluurp
Restart=always
LimitNOFILE=1048576
[Install]
WantedBy=multi-user.targetsudo systemctl enable --now sluurpStorage
Everything Sluurp keeps is in one folder, the data folder: --dir, or /data in the Docker image.
_system.db, default.db, one .db per project | The databases: your records, users, settings, pages, and the files server code keeps. |
storage/ | Files people upload, a folder per project. Usually the biggest part. |
snapshots/ | Backups, when you make them here. |
disk/ | Files server code keeps with Sluurp.disk, a folder per project. SLUURP_DISK puts them elsewhere. |
logs/ | Request logs older than a week, one gzipped file a day. |
bundles/ | Production bundles of your app, made at start. They can be rebuilt. |
Backups in the admin copy the databases only. Back up storage/ (or the SLUURP_FILES folder) as well, with your usual tools, or keep files in a bucket, below.
Files on a disk of their own
Uploads often outgrow the databases many times over. To keep them on another disk or volume, set SLUURP_FILES to a folder there:
SLUURP_FILES=/mnt/files sluurp --dir /srv/sluurp/data serve --public /srv/sluurp/appWith Docker, mount a volume for them. Either mount it where the files already go:
docker run -d -p 8090:8090 \
-v sluurp-data:/data \
-v /mnt/big-disk/sluurp:/data/storage \
-v "$PWD/app:/app" ghcr.io/sluurphq/sluurpor mount it anywhere and say where:
docker run -d -p 8090:8090 -e SLUURP_FILES=/files \
-v sluurp-data:/data -v sluurp-files:/files \
-v "$PWD/app:/app" ghcr.io/sluurphq/sluurpWhen you move existing files, stop Sluurp, copy the storage/ folder to the new place, then start it with the new setting.
The admin shows where the files are, and how much room is left on that disk, under Settings, Storage. The same screen sets how much the project, and each person, may upload; see Files.
Files in a bucket
With more than one server, or to keep files off the server, add an S3-compatible bucket: AWS S3, Cloudflare R2, Backblaze B2 or MinIO. Each upload is copied to the bucket, and a server that lacks a file fetches it from there. See Files for the settings.
Logs
Sluurp writes what it’s doing to the console. It keeps each request in its own database too, for the admin’s Logs screen, and archives requests older than a week to logs/, one gzipped file a day.
To send logs to Grafana (Loki), Splunk, Datadog, the ELK stack or anything else that reads JSON, turn on structured logs. They’re JSON lines, one object for each event, and every request is an event of its own:
{"timestamp":"2026-09-29T12:39:41.687Z","level":"INFO","target":"sluurp::http","message":"request","method":"GET","path":"/api/orders","status":200,"ms":3,"ip":"203.0.113.7","who":"users/k2x9"}| Setting | |
|---|---|
SLUURP_LOG_FILE=/var/log/sluurp/sluurp.log | JSON lines to that file, besides the console. A new file each day (sluurp.log.2026-09-29), and the last 14 kept. |
SLUURP_LOG_FORMAT=json | JSON lines to the console instead of text. For Docker and cloud platforms, whose log collectors read a container’s output. |
RUST_LOG=sluurp=debug | How much is logged, as usual. sluurp::http=off leaves requests out. |
Paths are logged without their query string, so a token in one never reaches a log. who is the account a request’s token names.
Then point your collector at the file. For Grafana Loki with Promtail:
scrape_configs:
- job_name: sluurp
static_configs:
- targets: [localhost]
labels: { job: sluurp, __path__: /var/log/sluurp/sluurp.log.* }
pipeline_stages:
- json: { expressions: { level: level, status: status, path: path } }
- labels: { level: , status: }For Splunk, Datadog or Elastic, their agents (the Universal Forwarder, the Datadog Agent, Filebeat, Vector, Fluent Bit) tail the same files and read JSON without extra set-up.
Many connections
One Sluurp handles tens of thousands of open connections: pages, API calls, live queries over WebSockets. Each one costs a few kilobytes and no thread. The operating system has limits of its own, though, and on Linux the first one is 1,024 open files per process. Every connection is an open file.
Sluurp raises its own limit as far as the system lets it when it starts. The LimitNOFILE line in the unit above lets it go that far. The server install script also sets these, and you can set them yourself on any Linux server:
net.core.somaxconn = 8192
net.ipv4.tcp_max_syn_backlog = 8192
net.ipv4.ip_local_port_range = 1024 65535
net.ipv4.tcp_tw_reuse = 1
fs.file-max = 2097152sudo sysctl --systemThey make room for a burst of new connections, give requests your functions make to other services all the local ports, and reuse closed sockets sooner. With Docker, pass --ulimit nofile=1048576:1048576 to docker run.
If Caddy or nginx sits in front, it holds a connection to each client and one to Sluurp, so give it the same limit.
Backups
sluurp backup backs up every project into a dated folder under snapshots/ in the data folder, while the server keeps running. Backups in the admin UI schedules them and sets how many to keep.
Each backup writes only what changed since the one before: the first holds the whole database, the next ones only the pages that rows added, changed or deleted touched, or a schema change. A 10 GB database backed up every night might take 10 GB once, then a few hundred MB a night. Each backup still restores whole by itself (sluurp restore), with no chain to replay.
Deleting an old backup moves the pages newer ones still need into the oldest of those first, so nothing they restore is lost. To fold a run of backups into one, as squashing commits does:
sluurp squash 2026-09-01T02-00-00Z-scheduled 2026-09-30T02-00-00Z-scheduledEvery backup from the first up to the second is removed except the second, which keeps what it restores and now stands alone.
Offsite
A backup on the same disk won’t survive that disk, so Sluurp can copy every backup to S3-compatible object storage: Cloudflare R2, AWS S3, Backblaze B2, MinIO or any other. Set it up in Backups → Offsite with the endpoint, bucket, an optional folder, an access key and a passphrase, and turn on Copy offsite after each scheduled backup.
- Encrypted before it leaves. Each copy is encrypted on the server with a key made from your passphrase (Argon2id, then AES-256-GCM). Neither the passphrase nor the data reaches the bucket in the clear, and object names don’t say what they hold. Keep the passphrase in your own records: without it, no copy can be read.
- Only what changed is sent. Copies are incremental like the backups themselves, so a nightly copy sends that day’s changes.
- Never deleted. A copy is written once and never replaced or removed from the server. A backup deleted, pruned or damaged on the machine stays as it was offsite.
- Secrets stay on the server. The secret key and the passphrase are kept encrypted with the master key and are never sent back out of the API.
The screen shows the last copy and any error, lists what is offsite, checks every copy (each object read back, opened and compared with what was written), and fetches one back to the machine. The same from the command line:
sluurp backup --offsite # back up, then copy what isn't offsite yet
sluurp backup list --offsite # what is offsite
sluurp backup verify --offsite # read every copy back and check it
sluurp backup fetch NAME # bring one back into snapshots/
sluurp restore latest --from-offsite # fetch the newest and restore it, server stoppedOn a new machine with no data yet, give the settings in the environment and restore:
SLUURP_OFFSITE_ENDPOINT=https://<account>.r2.cloudflarestorage.com
SLUURP_OFFSITE_BUCKET=backups
SLUURP_OFFSITE_PREFIX=my-app
SLUURP_OFFSITE_ACCESS_KEY_ID=...
SLUURP_OFFSITE_SECRET_ACCESS_KEY=...
SLUURP_OFFSITE_PASSPHRASE=...Settings in the environment win over the admin’s, which shows them as set by the server. SLUURP_OFFSITE_REGION is optional: auto by default, us-east-1 on AWS.
Upgrades
To upgrade, replace the binary and restart. When it starts, Sluurp upgrades its own tables and runs any app migrations still to run. Back up first; sluurp migrate APP --plan shows what will run.
Build ahead of time
Before deploying, sluurp build bundles an app into dist/ and packs it, with its migrations, into a .tar.gz named by its time and commit: what the server runs, with nothing to install there.