ecklf-tmp-runtime-test
Advanced tools
Rust Runtime for Vercel Functions.
Community-maintained package to support using Rust inside Vercel Functions as a Runtime.
The below documentation is for the vercel_runtime crate (in beta). If you are looking for the legacy runtime instructions using vercel_lambda see tree/a9495a0.
Please ensure Vercel CLI and the Rust toolchain is already installed on your system. We recommended setting up Rust with rustup.
Step 1 - Add a vercel.json file to your project.
{
"functions": {
"api/**/*.rs": {
"runtime": "vercel-rust@4.0.0-beta.4"
}
}
}
This turns every file matching api/**/*.rs into a Vercel Function.
Note: The npm dependency
vercel-rustdefined in functions does not have to be installed manually.
Step 2 - Create a function. As an example, here is api/handler.rs.
use serde_json::json;
use vercel_runtime::{run, Body, Error, Request, Response, StatusCode};
#[tokio::main]
async fn main() -> Result<(), Error> {
run(handler).await
}
pub async fn handler(_req: Request) -> Result<Response<Body>, Error> {
Ok(Response::builder()
.status(StatusCode::OK)
.header("Content-Type", "application/json")
.body(
json!({
"message": "你好，世界"
})
.to_string()
.into(),
)?)
}
Step 3 - Create a Cargo.toml in the root directory of your project.
[package]
name = "my-vercel-api"
version = "0.1.0"
edition = "2021"
[dependencies]
tokio = { version = "1", features = ["macros"] }
serde_json = { version = "1", features = ["raw_value"] }
# Documentation: https://docs.rs/vercel_runtime/latest/vercel_runtime
vercel_runtime = { version = "0.2.1" }
# You can specify a library for shared logic here (optional)
# [lib]
# path = "src-rs/lib.rs"
# Each handler has to be specified as [[bin]]
[[bin]]
name = "handler"
path = "api/handler.rs"
# Note that you need to provide unique names for each binary:
# [[bin]]
# name = "user-id"
# path = "api/user/[id].rs"
#
# [[bin]]
# name = "group-id"
# path = "api/group/[id].rs"
Step 4 - Create a .vercelignore in the root directory of your project to ignore build artifacts.
target/
Step 5 - You're all set. Run vercel dev to develop your project locally. You can connect a Git repository to Vercel, or use vercel to start deploying your project on Vercel.
An example on how this can be achieved is using a rust-toolchain file adjacent to your Cargo.toml. Please refer to Rust Documentation for more details.
By default builder module supports installing dependencies defined in the Cargo.toml file.
More system dependencies can be installed at build time with the presence of a shell build.sh file in the root directory of your project.
When creating a prebuilt deployment, the build output must be for x86_64 linux. To do this, create a Cargo build configuration at .cargo/config.toml with the following contents:
[build]
target = "x86_64-unknown-linux-musl"
# Uncomment below to support Rust cross-compilation from macOS to Linux
# Follow these installation instructions: https://github.com/chinedufn/cross-compile-rust-from-mac-to-linux
# [target.x86_64-unknown-linux-musl]
# linker = "x86_64-unknown-linux-gnu-gcc"
You then can build the file and trigger the deployment via Vercel CLI.
vercel build && vercel deploy --prebuilt
Unfortunately, the AWS Lambda Runtime for Rust relies (tangentially) on proc_macro, which won't compile on musl targets. Without musl, all linking must be dynamic. If you have a crate that relies on system libraries like postgres or mysql, you can include those library files with the includeFiles config option and set the proper environment variables, config, etc. that you need to get the library to compile.
For more information, please see this issue.
This feature allows you to bundle all of your routes into a single deployed Vercel function. Besides optimizing for cold starts, this has the additional benefit of you only needing to annotate a single [[bin]] in your Cargo.toml.
Enable this feature by setting the following environment variable in your Vercel project.
VERCEL_RUST_EXPERIMENTAL_ROUTE_MERGE=true
In case you are using workspaces (like examples/route-merge in this repository), an additional macro prefix has to be provided as an environment variable both locally and in your Vercel project.
# Example for `vercel dev`
VERCEL_RUST_EXPERIMENTAL_MACRO_PREFIX=examples/route-merge/ VERCEL_RUST_EXPERIMENTAL_ROUTE_MERGE=true vc dev
Create a api/vercel/index.rs.
use serde_json::json;
use vercel_runtime::{include_api, run, Body, Error, Request, Response, StatusCode};
#[tokio::main]
async fn main() -> Result<(), Error> {
run(handler).await
}
// Proc macro which injects a router for files matching the glob `api/**/[!index]*.rs`.
#[include_api]
pub async fn handler(req: Request) -> Result<Response<Body>, Error> {
Ok(Response::builder()
.status(StatusCode::NOT_FOUND)
.header("Content-Type", "application/json")
.body(
json!({
"code": "not_found",
"message": "not_found"
})
.to_string()
.into(),
)?)
}
Change your vercel.json to only specify your api/vercel/index.rs file.
{
"functions": {
"api/vercel/index.rs": {
"runtime": "vercel-rust@4.0.0-canary.4"
}
}
}
Change your Cargo.toml to only specify the binary for index.rs.
[[bin]]
name = "index"
path = "api/vercel/index.rs"
Every route in api/** must contain a handler function for the router to work.
// Example api/foo.rs
use vercel_runtime::{Body, Error, Request, Response, StatusCode};
pub async fn handler(_req: Request) -> Result<Response<Body>, Error> {
Ok(Response::builder()
.status(StatusCode::OK)
.header("Content-Type", "application/json")
.body(Body::Text("Route is /api/foo".into()))?)
}
Since this project contains both Rust and Node.js code, you need to install the relevant dependencies. If you're only working on the TypeScript side, you only need to install those dependencies (and vice-versa).
# install node dependencies
pnpm install
# install cargo dependencies
cargo fetch
The npm module vercel-rust is implementing an interface which is primarily taking care of spawning a development server, caching between consecutive builds, and running the compilation. You can read more about the in-depths of implementing a builder here.
Note that this dependency does not have to be installed manually as it is pulled automatically.
The crate vercel_runtime is what you will consume in your Rust functions. As the name suggests, the runtime crate takes care of everything that happens during run-time. In specific it takes care of creating a Tower service, which expects a specific handler signature. The flow of an invocation can be visualized as the following:
graph TD
A["Function Invocation"] --> |"process_request(event: InvocationEvent<VercelEvent>) → Request"| B[Request]
B --> |"handler_fn(req: Request) → Future<Output = Result<Response<Body>, Error>>"| C["Runtime calls handler_fn"]
C --> |"Ok(r) => process_response(r)"| D["Response"]
FAQs
Rust runtime for Vercel Functions.
We found that ecklf-tmp-runtime-test demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
Security News
Socket researchers have discovered multiple malicious npm packages targeting Solana private keys, abusing Gmail to exfiltrate the data and drain Solana wallets.
Security News
PEP 770 proposes adding SBOM support to Python packages to improve transparency and catch hidden non-Python dependencies that security tools often miss.
Security News
Socket CEO Feross Aboukhadijeh discusses open source security challenges, including zero-day attacks and supply chain risks, on the Cyber Security Council podcast.