Product
Socket Now Supports uv.lock Files
Socket now supports uv.lock files to ensure consistent, secure dependency resolution for Python projects and enhance supply chain security.
By Trevor Norris - Jan 09, 2025
Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
ecklf-tmp-runtime-test
Advanced tools
Rust
Rust Runtime for Vercel Functions.
Community-maintained package to support using Rust inside Vercel Functions as a Runtime.
Legacy 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.
Getting Started
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.
Advanced Usage
Toolchain Overrides
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.
Dependencies
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.
Prebuilt Deployments
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
Musl/Static linking
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.
Experimental Route Merge
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()))?)
}
Contributing
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
Builder Module
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.
Runtime Crate
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.
The npm package ecklf-tmp-runtime-test receives a total of 200 weekly downloads. As such, ecklf-tmp-runtime-test popularity was classified as not popular.
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.
Package last updated on 13 Apr 2023
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.
Related posts
Research
Security News
Gmail For Exfiltration: Malicious npm Packages Target Solana Private Keys and Drain Victims' Wallets
Socket researchers have discovered multiple malicious npm packages targeting Solana private keys, abusing Gmail to exfiltrate the data and drain Solana wallets.
By Kirill Boychenko - Jan 08, 2025
Security News
New Python Packaging Proposal Aims to Solve Phantom Dependency Problem with SBOMs
PEP 770 proposes adding SBOM support to Python packages to improve transparency and catch hidden non-Python dependencies that security tools often miss.
By Sarah Gooding - Jan 07, 2025