Your own Render,on one machine

Get started View on GitHub

Deploy from a git repo, a folder or a Docker image, with zero downtime. Add Postgres, Redis, cron jobs, custom domains and HTTPS, all on one server with Docker.

Get started View on GitHub

Install it on a fresh Ubuntu or Debian server with one command:

$ curl -fsSL https://github.com/rogerbentcha/ferry/releases/latest/download/install.sh | sudo sh

$ ferry up --follow
Packing /home/you/my-app …
Packed 38 file(s), 96.2 KiB
Uploading 96.2 KiB …
Deploy dep-q4m8x2k7c1w9v5b3n6ta queued (upload), streaming logs…
==> Starting deploy dep-q4m8x2k7c1w9v5b3n6ta (trigger: upload)
==> Extracting uploaded source archive
==> Detected Node.js runtime
==> Building image ferry/my-app:dep-q4m8x2k7c1w9v5b3n6ta
added 214 packages, and audited 215 packages in 4s
> [email protected] build
==> Build successful 🎉
==> Starting 2 instance(s)
==> Waiting for 2 instance(s) to become healthy: GET /healthz must answer with a status below 400 (timeout 120s)
==> Health check passed
==> Routing traffic to the new instance(s)
==> Stopping 2 old instance(s)
==> Your service is live 🎉
==> Available at https://my-app.example.com

ferry up packs the folder, builds it and starts the new deploy next to the live one. Once its health check passes, the proxy sends it every new request in one step, and the old deploy stops after answering the requests it already had. Put the pointer on the harbor to slow the deploy down.

Builds and runs the stack you already have

Node.js
Python
Go
Rust
Ruby
Dockerfile
Postgres
Redis
GitHub
GitLab
Let’s Encrypt
nginx

Everything your apps needfrom the deploy to the database

Zero-downtime deploys

Every deploy starts next to the live one and only gets traffic once its health check passes.

Health checks before traffic
One-click rollbacks
Crashed containers replaced

Services

Run web services, private services, workers, cron jobs and static sites.

shopWeb service

apiPrivate service

mailerBackground worker

nightly-reportCron job

docsStatic site

Postgres & Redis

Managed databases on persistent volumes, wired into your services by reference.

DATABASE_URL=${{datastore.shop-db.connectionString}}

Domains & HTTPS

A URL for every service. Custom domains get HTTPS from Let’s Encrypt.

shop.example.com

api.example.com

status.example.comIssuing

Cron jobs

Scheduled jobs on a cron expression, plus one-off runs such as migrations.

schedule: "0 3 * * *"

Last 14 runsNext at 03:00 UTC

Logs & metrics

Live build and runtime logs, with CPU and memory for every service.

CPU37%

12:04:31 [a1b2c3] GET /api/orders 200 12ms

12:04:32 [d4e5f6] GET /healthz 200 1ms

12:04:32 [a1b2c3] POST /api/checkout 201 48ms

Blueprints

Describe the whole stack in one file. Render’s render.yaml works as it is.

services:  - type: web    name: shop    numInstances: 2  - type: cron    schedule: "0 3 * * *"databases:  - name: shop-db

One binary on one machine. The API, the dashboard, the builder, the proxy and the scheduler all run inside ferryd, and Docker is the only dependency.

Deploy froma git repository

GitHub, GitLab, any SSH URL or a local path. Add a GitHub webhook and every push to the branch deploys.

No Dockerfile needed: Ferry detects Node.js, Python, Go, Rust, Ruby and static sites, and uses your Dockerfile when there is one.

How builds work

$ ferry create api --repo https://github.com/you/api --branch main --followCreated web service 'api' (srv-8k2m4x7q1c9w5v3b6n0t)URL: https://api.example.comDeploy dep-c5n8x1q7k2w9v4b6m3ta queued (create), streaming logs…==> Cloning from https://github.com/you/api (branch main)==> Checked out 7c1e2f4: Add a health check==> Detected Node.js runtime==> Build successful 🎉==> Health check passed==> Your service is live 🎉==> Available at https://api.example.com

One command on a fresh serveror build it on your own machine

On Ubuntu 22.04, 24.04 or 26.04, or Debian 12 or 13 (x86_64 or arm64), the install script sets up Docker, git and Ferry as a systemd service. Elsewhere you need Docker, and Docker Desktop is fine on a Mac. To build from source you also need Rust 1.89 or later and Node.js 20 or later.

Install on your server
Run it as root or with sudo. Run it again to upgrade: your apps, data and settings stay.
```
$ curl -fsSL https://github.com/rogerbentcha/ferry/releases/latest/download/install.sh | sudo sh
```
Open the dashboard
The script ends with an SSH tunnel and a link. Run the tunnel on your computer, then open the link to create your account.
```
$ ssh -N -L 7878:127.0.0.1:7878 root@your-server
```

Or build and start it on your machine

ferryd starts in the background and prints a link: open it to create your account. ferryd stop stops the server.

$ git clone https://github.com/rogerbentcha/ferry && cd ferry$ (cd web && npm ci && npm run build)$ cargo build --release$ ./target/release/ferryd

Deploy the example app

In the clone, ferry login opens the dashboard, where you approve the terminal. The dashboard is at http://127.0.0.1:7878.

$ export PATH="$PWD/target/release:$PATH"$ ferry login$ cd examples/node-hello && ferry up --follow$ curl http://node-hello.localhost:8080

Put it on a server

Point a wildcard DNS record at the server, then give the install script your domain with --base-domain. Add --acme-email and it gets HTTPS certificates from Let’s Encrypt.

Read the production guide

Click, type or script it

Manage everything from the web dashboard, the ferry CLI or the REST API. The API is described in OpenAPI 3.1, and each server has its own Swagger UI at /api/docs.

Browse the API reference

Open source, MIT licensedRead it, run it, change it

Ferry is built in the open, in Rust. Your apps run as plain Docker containers and your data stays in Docker volumes on your own machine.

View on GitHub How it’s built

Nine crates, one workspace

ferrydThe server: wires everything together
ferry-apiREST API, live events, OpenAPI, the dashboard
ferry-engineDeploys, the reconciler, cron, datastores, logs
ferry-buildGit fetch, runtime detection, image builds
ferry-proxyReverse proxy with HTTP/2 and WebSockets
ferry-tlsCertificates from Let’s Encrypt
ferry-dockerA typed Docker client
ferry-coreModels, the SQLite store, validation
ferry-cliThe ferry command