Coming soon
Deploy where you own. Pay 10x less.
pks-aspire-coolify
A one-line Aspire hosting extension that ships your whole AppHost to a Coolify host on your own cheap Hetzner or Scaleway VPS — a roughly 10x saving over the big clouds, with no deploy pipeline you don't control.
Aspire makes building easy. The big clouds make shipping expensive.
You modelled your whole system in `AppHost.cs` — projects, containers, references, environments — and it runs beautifully on your machine. Then comes deploy, and the only well-trodden path is a managed cloud: a metered control plane, a per-resource bill, and a pipeline you can't fully see into. The graph you wrote so deliberately gets handed to infrastructure you rent and don't own. Coolify already models destinations, projects, environments, and services on a VPS you do own — so we built the one piece that was missing: the bridge from your Aspire graph to that owned hardware, in a single line.
Managed clouds meter every resource and every deploy — costs that scale with exactly what Aspire produces: many small services, deployed often.
A Hetzner or Scaleway VPS running Coolify costs roughly a tenth of the equivalent managed footprint — and the box is yours, not rented compute you can't reason about.
The "easy" cloud deploy is a black-box pipeline: you can't read the bill line by line, you can't move it, and you don't own the hardware your agents ship to.
How it works
Add one line to your AppHost.
Chain `.WithCoolifyDeploy(url, token)` onto your builder, point it at your Coolify host, and pick a destination. No `using` directive, no new resource types — it lives in the `Aspire.Hosting` namespace right next to `WithRedis` and `WithPostgres`.
Pass your token as a secret.
`AddParameter("coolify-token", secret: true)` — a typed handle, never a value in source. The configure phase fails fast with a clear symbol (`E_AUTH_TOKEN_MISSING`, `E_COOLIFY_UNREACHABLE`, …) before any side-effecting work runs.
Run `aspire deploy`.
The publisher walks five fixed phases in order — configure → build → push → deploy → verify. It builds your images, pushes them to your registry, and upserts the Coolify project, environments, and services to match your graph.
Re-run any time.
Deploys are name-keyed and idempotent: running `aspire deploy` again converges your Coolify host to the current graph instead of duplicating anything. One AppHost stays one Coolify project, deploy after deploy.
One line, no new directive
`.WithCoolifyDeploy(url, token)` chains onto your existing builder in the `Aspire.Hosting` namespace — the same shape as `WithRedis` or `WithPostgres`, nothing new to learn.
Five deliberate phases
Every deploy walks configure → build → push → deploy → verify in fixed order, so you always know exactly where you are in the pipeline.
Fail fast, fail clearly
The configure phase refuses to advance on a bad token or an unreachable host, surfacing one of four diagnostic symbols before any side-effecting work begins.
Idempotent re-deploys
Name-keyed upserts mean one AppHost maps to one Coolify project; re-running `aspire deploy` converges your host instead of duplicating projects or services.
Your graph, mapped cleanly
Each Aspire environment becomes a Coolify environment and each containerisable resource a Coolify service — your `AppHost.cs` mental model survives the round-trip.
Secrets as typed handles
Coolify URL, token, and registry flow in as Aspire parameters — `secret: true` for the token — never as plaintext in your source.
A hand-written client, not a generated dependency. The bridge to Coolify is a thin, hand-written REST client we pin and own — not an SDK we can't see into. Every phase and every diagnostic is a decision we took deliberately.
You own the destination. The whole point is that the hardware on the other end is yours: your Coolify host, your Hetzner or Scaleway VPS, your registry. We own the publisher; you own the box it ships to.
Runs everywhere Coolify does. A homelab server, a single Hetzner box, a Scaleway instance — the same one line deploys the same graph to any of them. No managed control plane in the path you can't move off of.
Composable by design. It's the top delivery layer that sits still under the rest of the suite: the lower layers produce the graph and the images, and this one ships them — to hardware you control, for roughly 10x less.
Composes with
Your Aspire app. Shipped to hardware you own.
pks-aspire-coolify hooks `aspire deploy` straight into your own Coolify host. One line in your AppHost turns your full resource graph into a running deployment on a Hetzner or Scaleway VPS — for roughly a tenth of what the big clouds charge. Same code, same `aspire deploy`, a bill you can finally read.