Shuttle Documentation

To use the Poem web framework with Shuttle, use the ShuttlePoem type in your main function. Your main function should be annotated with #[shuttle_runtime::main] and return a ShuttlePoem<impl poem::Endpoint>. You can convert a Poem Route into a ShuttlePoem using the .into() method.

use poem::{get, handler, Route};
use shuttle_poem::ShuttlePoem;

#[handler]
fn hello_world() -> &'static str {
    "Hello, world!"
}

#[shuttle_runtime::main]
async fn poem() -> ShuttlePoem<impl poem::Endpoint> {
    let app = Route::new().at("/", get(hello_world));

    Ok(app.into())
}

You can create a new project using a template. For example, to initialize a project with Axum boilerplate, use the shuttle init command with the --template flag.

shuttle init --template axum my-axum-app

If your project requires Axum 0.7 instead of the default Axum 0.8, you must disable default features for shuttle-axum and explicitly enable the axum-0-7 feature flag in your Cargo.toml.

axum = "0.7.3"
shuttle-axum = { version = "...", default-features = false, features = ["axum-0-7"] }

To develop Shuttle locally, clone the repository and initialize the linked examples submodule.

git clone git@github.com:shuttle-hq/shuttle.git
cd shuttle
git submodule init
git submodule update

To extend Shuttle with custom managed resources, you must implement the ResourceInputBuilder trait. You can find implementation patterns by examining existing plugins in the repository or by reviewing the official custom resource examples in the shuttle-examples repository.

https://github.com/shuttle-hq/shuttle-examples/tree/main/custom-resource

To use Salvo with Shuttle, define your main function using the #[shuttle_runtime::main] attribute and return a shuttle_salvo::ShuttleSalvo type. You can convert a Salvo Router into this type using the .into() method.

use salvo::prelude::*;

#[handler]
async fn hello_world(res: &mut Response) {
    res.render(Text::Plain("Hello, world!"));
}

#[shuttle_runtime::main]
async fn salvo() -> shuttle_salvo::ShuttleSalvo {
    let router = Router::new().get(hello_world);

    Ok(router.into())
}

To use OpenDAL with your Shuttle service, add the shuttle-opendal crate to your dependencies using cargo:

cargo add shuttle-opendal

Install the Shuttle CLI to deploy Rust applications using a single command. Use the appropriate command for your operating system.

# Linux / macOS
curl -sSfL https://www.shuttle.dev/install | bash

# Windows (Powershell)
iwr https://www.shuttle.dev/install-win | iex

To deploy a Rocket application on Shuttle, use the shuttle_rocket::ShuttleRocket type as the return type for your #[shuttle_runtime::main] entry point. You can convert a standard Rocket instance into a Shuttle-compatible service using the .into() method.

use rocket::{get, routes};

#[get("/")]
fn index() -> &'static str {
    "Hello, world!"
}

#[shuttle_runtime::main]
async fn rocket() -> shuttle_rocket::ShuttleRocket {
    let rocket = rocket::build().mount("/", routes![index]);

    Ok(rocket.into())
}