# Where to deploy a Rust web service in Europe in 2026

Last updated: 2026-11-10

For an Axum, Actix Web or Rocket service you want to push from Git without writing a Dockerfile, **Clever Cloud** has a dedicated Rust runtime that runs `cargo build --release` for you, and **Upsun** builds Cargo projects with a hook you write in its config file. If you'd rather ship your own multi-stage Dockerfile, **Sliplane** gives you a fixed monthly server price, **Scaleway Serverless Containers** bills only while the container runs, and **Coolify on a Hetzner server** keeps costs low if you're willing to run the machine.

## Rust hosting options at a glance

| Platform | Company based in | How Rust gets built | Managed Postgres | Starts at |
|---|---|---|---|---|
| Clever Cloud | France | Native Rust runtime, `cargo build --release --locked` | Yes, as an add-on | Billed by the second, see its calculator |
| Upsun | Paris, France | `rust:1` image, your own `cargo build` hook | Yes, as a service | €9 a project and €10 a user a month, plus resources |
| Sliplane | Berlin, Germany | Your Dockerfile or a pushed image | From €19, excl. VAT | €9 a server, excl. VAT |
| Scaleway | France | Your image, or a Rust function | Sold separately | Free monthly allowance, then billed by use |
| Coolify on Hetzner | Germany, for the Hetzner server | Your Dockerfile, Compose file or image | You run it yourself | Server listed from €5.49 a month excl. VAT |
| Eurobase | Warsaw, Poland | Not supported | No | Not an option for Rust today |

Prices are from each provider's own page, checked on 9 and 10 November 2026.

## What to check before you deploy Rust

- **Build memory and time.** A release build of a mid-sized Rust project can need far more memory than the binary needs at runtime. Find out whether the platform lets you build on a bigger machine than the one that serves traffic.
- **Native runtime or Dockerfile.** A native runtime knows about Cargo, lockfiles and toolchains. A Dockerfile gives you full control, including `musl` targets and a tiny final image, but you maintain it.
- **Toolchain pinning.** Check whether a `rust-toolchain.toml` file is honoured, so builds don't change when a new stable release lands.
- **Scale to zero or always on.** A Rust binary usually starts fast, which makes scale-to-zero billing more attractive than it is for heavier runtimes.
- **Where the database sits.** Most Rust web services talk to Postgres through SQLx or Diesel. A database from the same provider keeps that traffic on one network and one invoice.

## 1. Clever Cloud

Clever Cloud's Rust runtime takes a Cargo project with at least one binary target and a committed `Cargo.lock`, vendors the dependencies, then compiles with `cargo build --release --locked`. A missing or stale lockfile fails the build. It starts the binary named in `CC_RUST_BIN`, otherwise the `default-run` target, otherwise the single binary it finds, and your server has to bind to `0.0.0.0` on the port in `PORT`. A `rust-toolchain.toml` file takes priority over the `CC_RUSTUP_CHANNEL` variable, the build image carries clang, lld, pkg-config and OpenSSL for crates with C code, and `CC_RUST_FEATURES` turns on Cargo features. The same project can also run as a Clever Task for one-off jobs such as migrations. The company is French and says it runs its own datacenters there. PostgreSQL, MySQL and Redis are available as add-ons.

- **Best for:** teams that want a Rust-aware build on a push, next to a managed database.
- **Price:** billed by the second for what you run, with a calculator on its pricing page. Its docs recommend a dedicated build instance of at least size S for most Rust projects, which you pay for while it builds.

## 2. Upsun

Upsun is the trading name of Platform.sh SAS, a Paris company. Its Rust image is selected with `type: 'rust:1'` in `.upsun/config.yaml`, dependencies come through Cargo from your committed `Cargo.toml` and `Cargo.lock`, and you write the `cargo build` step in a build hook and the binary path in the start command. An Nginx proxy sits in front of your app, and the port arrives in the `PORT` variable. The documentation's example builds in debug mode, so add `--release` to the hook and point the start command at `target/release`.

- **Best for:** teams that want a database, cache and several environments described in one config file.
- **Price:** a €9 project fee and €10 for each user a month, with CPU and memory added on top and billed per second. New accounts get a 15-day free trial.
- **What it lacks:** a fixed bill, since resources are added on top. Its regions run on AWS, Azure, Google Cloud or OVHcloud, and the [regions page](https://docs.upsun.com/development/regions.html) shows which provider is behind each one.

## 3. Sliplane

Sliplane rents you a server and runs your containers on it, built from a GitHub repository or pulled as a Docker image, with zero-downtime releases, logs and metrics included. It detects common frameworks automatically, but for Rust you'll usually get a smaller image and a faster start by committing your own multi-stage Dockerfile: compile in a Rust image, then copy the binary into a slim runtime image.

- **Best for:** a few Rust services and one database at a price that doesn't move with traffic.
- **Price:** servers from €9 for 1 vCPU, 1 GB of RAM and 20 GB of storage, and managed PostgreSQL from €19, all excl. VAT.
- **Where it runs:** its server locations include regions outside Europe, so choose an EU one when you create the server.

## 4. Scaleway

Scaleway, a French cloud provider, gives you two routes. Serverless Containers run any image you push, in Paris, Amsterdam, Warsaw or Milan, and scale from zero up to 200 instances. Serverless Functions list Rust among their runtimes, alongside Node.js, Python, Go and PHP, for handlers that don't need a full web server.

- **Best for:** teams that already build images in CI and want to pay only while requests arrive.
- **Price:** for containers, the first 400,000 GB-s of memory and 200,000 vCPU-s each month are free, and after that you pay €0.20 per 100,000 GB-s and €1 per 100,000 vCPU-s. For Functions, the free share is 400,000 GB-s and 1 million requests a month, then €0.50 per 100,000 GB-s and €0.15 per million requests.
- **What it lacks:** a database in the same product. Managed databases are bought and billed separately.

## 5. Coolify on Hetzner

Coolify is open-source software you install on your own server. It deploys an application from a Git repository, from a Dockerfile entered without Git, from a Docker Compose file or from an existing image, and connects to GitHub, GitLab, Bitbucket, Gitea and other Git hosts. Hetzner, a German host, supplies the machine.

- **Best for:** a small budget and someone on the team who's at home on a Linux server.
- **Price:** Hetzner's CPX02, with 1 AMD vCPU, 1 GB of RAM and 20 GB of NVMe, is listed from €5.49 a month excl. VAT in Helsinki, or €6.49 a month in Falkenstein and Nuremberg. On 10 November 2026 its order page showed that plan as unavailable to order. Self-hosted Coolify is free.
- **What it lacks:** someone else looking after the server. Updates, backups and security stay with you, and 1 GB of RAM is tight for compiling Rust on the same box, so build the image elsewhere or pick a bigger server.

## Where Eurobase fits

Eurobase isn't a fit for a Rust web service today. Its containers are built from source with Paketo buildpacks for Node.js, Python, Go, Java, Ruby, PHP and .NET, Rust isn't on that list, and Dockerfiles aren't used, so there's no way to hand it a Rust binary. If part of your product is a Node.js, Python or Go app, a Workers app or a static frontend, Eurobase can host that part on European infrastructure run by Scaleway, a French provider, while the Rust API runs on one of the options above. It has a Free plan, then €10 or €20 a month + VAT, and no usage charges today: work over a limit is refused, apps on V8 isolates and Functions stop until the monthly reset, and containers and static sites keep serving. It has no managed Postgres or preview deployments, and its ISO 27001 and SOC 2 work isn't finished yet.

## How to choose

- You want `git push` and a Rust-aware build with no Dockerfile: **Clever Cloud**.
- You want app, database and environments in one YAML file: **Upsun**.
- You have a Dockerfile and want a flat server price: **Sliplane**.
- Your CI already pushes images and traffic is spiky: **Scaleway Serverless Containers**.
- Budget matters most and you can run a server: **Coolify on Hetzner**.

## Frequently asked questions

### Can I deploy Axum or Actix Web without a Dockerfile in Europe?

Yes. Clever Cloud's Rust runtime builds a Cargo project directly and names Axum, Actix Web and Rocket in its docs. Upsun also builds from `Cargo.toml`, with the build command written in its config file.

### Why does my Rust build fail on a small instance?

Compiling Rust uses much more memory and CPU than running the finished binary. Use a larger build machine where the platform offers one, as Clever Cloud does, or compile in CI and deploy a ready image to Sliplane, Scaleway or Coolify.

### What's the cheapest way to host a Rust API in the EU?

For light or bursty traffic, Scaleway's monthly free allowance can cover a small container. For steady traffic, a Hetzner server with Coolify has the lowest listed price here, though its cheapest plan wasn't orderable on 10 November 2026, and Sliplane starts at €9 excl. VAT with the server managed for you.

### Does Eurobase support Rust?

No. Eurobase builds Node.js, Python, Go, Java, Ruby, PHP and .NET apps and doesn't use Dockerfiles, so a Rust service needs another host. See [Docker hosting in Europe](/i/docker-hosting-europe) for platforms that run your own image.

## Sources

- [Clever Cloud Rust runtime](https://www.clever.cloud/developers/doc/deploy/applications/rust/) and [Clever Cloud pricing](https://www.clever.cloud/pricing/)
- [Upsun Rust docs](https://developer.upsun.com/docs/languages/rust), [Upsun pricing](https://upsun.com/pricing/) and [Upsun regions](https://docs.upsun.com/development/regions.html)
- [Sliplane](https://sliplane.io/) and [Sliplane pricing](https://sliplane.io/pricing)
- [Scaleway Serverless Containers](https://www.scaleway.com/en/serverless-containers/), [Scaleway serverless pricing](https://www.scaleway.com/en/pricing/serverless/) and [Scaleway Functions runtimes](https://www.scaleway.com/en/docs/serverless-functions/reference-content/functions-runtimes/)
- [Coolify applications](https://coolify.io/docs/applications/) and [Hetzner Regular Performance](https://www.hetzner.com/cloud/regular-performance/)
- [Eurobase containers](/docs/containers), [Eurobase plans and limits](/docs/plans), [Eurobase pricing](/pricing), [Docker hosting in Europe](/i/docker-hosting-europe) and [Serverless functions in Europe](/i/european-aws-lambda-alternatives)