Run Rust web server frameworks on AWS Lambda. Currently, it supports Actix web, axum, Rocket, warp.
Cargo.toml
```toml [[bin]] name = "bootstrap" path = "src/main.rs"
[dependencies] lambda-web = { version = "0.1.8", features=["actix4"] } ```
main.rs
```rust use lambdaweb::actixweb::{self, get, App, HttpServer, Responder}; use lambdaweb::{isrunningonlambda, runactixon_lambda, LambdaError};
async fn hello() -> impl Responder { format!("Hello") }
async fn main() -> Result<(),LambdaError> { let factory = move || { App::new().service(hello) };
if is_running_on_lambda() {
// Run on AWS Lambda
run_actix_on_lambda(factory).await?;
} else {
// Local server
HttpServer::new(factory)
.bind("127.0.0.1:8080")?
.run()
.await?;
}
Ok(())
} ```
Cargo.toml
```toml [[bin]] name = "bootstrap" path = "src/main.rs"
[dependencies] lambda-web = { version = "0.1.8", features=["hyper"] } axum = "0.3" tokio = { version = "1" } ```
main.rs
```rust use axum::{routing::get, Router}; use lambdaweb::{isrunningonlambda, runhyperon_lambda, LambdaError}; use std::net::SocketAddr;
// basic handler that responds with a static string async fn root() -> &'static str { "Hello, World!" }
async fn main() -> Result<(), LambdaError> { // build our application with a route let app = Router::new().route("/", get(root));
if is_running_on_lambda() {
// Run app on AWS Lambda
run_hyper_on_lambda(app).await?;
} else {
// Run app on local server
let addr = SocketAddr::from(([127, 0, 0, 1], 8080));
axum::Server::bind(&addr).serve(app.into_make_service()).await?;
}
Ok(())
} ```
Cargo.toml
```toml [[bin]] name = "bootstrap" path = "src/main.rs"
[dependencies] lambda-web = { version = "0.1.8", features=["rocket05"] } rocket = "0.5.0-rc.1" ```
main.rs
```rust use rocket::{self, get, routes}; use lambdaweb::{isrunningonlambda, launchrocketon_lambda, LambdaError};
fn hello(name: &str, age: u8) -> String { format!("Hello, {} year old named {}!", age, name) }
async fn main() -> Result<(), LambdaError> { let rocket = rocket::build().mount("/", routes![hello]); if isrunningonlambda() { // Launch on AWS Lambda launchrocketonlambda(rocket).await?; } else { // Launch local server rocket.launch().await?; } Ok(()) } ```
Cargo.toml
```toml [[bin]] name = "bootstrap" path = "src/main.rs"
[dependencies] lambda-web = { version = "0.1.8", features=["hyper"] } warp = "0.3" tokio = { version = "1" } ```
main.rs
```rust use lambdaweb::{isrunningonlambda, runhyperon_lambda, LambdaError}; use warp::Filter;
async fn main() -> Result<(), LambdaError> { // GET /hello/warp => 200 OK with body "Hello, warp!" let hello = warp::path!("hello" / String).map(|name| format!("Hello, {}", name));
if is_running_on_lambda() {
// Run on AWS Lambda
run_hyper_on_lambda(warp::service(hello)).await?;
} else {
// Run local server
warp::serve(hello).run(([127, 0, 0, 1], 8080)).await;
}
Ok(())
} ```
As of writing (Nov, 2021), we have two options to run Rust on AWS Lambda: Amazon Linux 2 custom runtime or Docker container image.
I recommend ZIP deploy to Amazon Linux 2 custom runtime (provided.al2) because it's faster cold start time than container image.
To build Amazon Linux 2 compatible binary, see Deploy.md for more details.
provided.al2 custom runtime. Choose "Provide your own bootstrap on Amazon Linux 2" ./ and attach Lambda proxy integration./{proxy+} and attach Lambda proxy integration.*/* binary media type.