Crate shuttle_service

Shuttle - Deploy Rust apps with a single Cargo subcommand

Hello, and welcome to the shuttle API documentation!

Shuttle is an open-source app platform that uses traits and annotations to configure your backend deployments.

Usage

Depend on shuttle-service in Cargo.toml:

shuttle-service = "0.2"

and make sure your crate has a cdylib output target:

[lib]
crate-type = ["cdylib"]

See the shuttle_service::main macro for more information on how to implement a service. Here’s a simple example using [rocket][rocket] to get you started:

#[macro_use]
extern crate rocket;

use rocket::{Build, Rocket};

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

#[shuttle_service::main]
async fn init() -> Result<Rocket<Build>, shuttle_service::Error> {
    let rocket = rocket::build().mount("/", routes![hello]);

    Ok(rocket)
}

Complete examples can be found in the repository.

Deploying

You can deploy your service with the cargo shuttle subcommand. To install run:

$ cargo install cargo-shuttle

in a terminal. Once installed, run:

$ cargo shuttle login

this will open a browser window and prompt you to connect using your GitHub account.

Then, deploy the service with:

$ cargo shuttle deploy

Your service will immediately be available at {crate_name}.shuttleapp.rs. For example:

$ curl https://hello-world-rocket-app.shuttleapp.rs
Hello, world!

Using sqlx

Here is a quick example to deploy a service which uses a postgres database and sqlx:

#[macro_use]
extern crate rocket;

use rocket::{Build, Rocket};
use sqlx::PgPool;

struct MyState(PgPool);

#[get("/hello")]
fn hello(state: &State<MyState>) -> &'static str {
    // Do things with `state.0`...
    "Hello, Postgres!"
}

#[shuttle_service::main]
async fn rocket(pool: PgPool) -> Result<Rocket<Build>, shuttle_service::Error> {
    let state = MyState(pool);
    let rocket = rocket::build().manage(state).mount("/", routes![hello]);

    Ok(rocket)
}

To learn more about shuttle managed services, see shuttle_service::main.

Configuration

The cargo shuttle command can be customised by creating a Shuttle.toml in the same location as your Cargo.toml.

Getting API keys

After you’ve installed the cargo-shuttle command, run:

$ cargo shuttle login

this will open a browser window and prompt you to connect using your GitHub account.

Change the name of your service

To have your service deployed with a different name, add a name entry in the Shuttle.toml:

name = "hello-world"

If the name key is not specified, the service’s name will be the same as the crate’s name.

We’re in alpha 🤗

Thanks for using shuttle! We’re very happy to have you with us!

During our alpha period, API keys are completely free and you can deploy as many services as you want.

Just keep in mind that there may be some kinks that require us to take all deployments down once in a while. In certain circumstances we may also have to delete all the data associated with those deployments.

To stay updated with the release status of shuttle, join our Discord!

Join Discord

If you have any questions, join our Discord server. There’s always someone on there that can help!

You can also open an issue or a discussion on GitHub.

Re-exports

pub use error::Error;

Modules

error

Types representing various errors that can occur in the process of building and deploying a service.

Macros

declare_service

Helper macro that generates the entrypoint required of any service.

Structs

SimpleService

A wrapper that takes a user’s future, gives the future a factory, and takes the returned service from the future The returned service will be deployed by shuttle

Traits

Factory

Factories can be used to request the provisioning of additional resources (like databases).

GetResource

Used to get resources of type T from factories.

IntoService

A convenience trait for handling out of the box conversions into Service instances.

Service

The core trait of the shuttle platform. Every crate deployed to shuttle needs to implement this trait.

Type Definitions

StateBuilder

Attribute Macros

main

Helper macro that generates the entrypoint required by any service - likely the only macro you need in this crate.