Serverless Functions using Rust and WebAssembly

Front Line (Web) Assembly

Background

In a previous post I gave an overview of how to create functions for Oracle Functions or Fn Project, when you want to use a language for which there is no FDK (Function Development Kit).

The approach I took was to create a "helper function" which provides a bare minimum interface between Fn and the function.

This is all well and good, but it is not a full FDK.  Some of the capabilities of the supported FDKs are absent.  For example, the helper is not aware of values that have been configured for the function or application via the context.

So in this post, I want to explore a different approach, which will

• enable the capabilities of the provided FDKs
• support functions in a language for which there is no FDK

WebAssembly

WebAssembly ("wasm") is an open standard W3C that defines a portable binary format.  By compiling code to WebAssembly we are able to run it in a browser.  This means that developers can

• write code in a language other than JavaScript
• compile it to WebAssembly
• run it in the browser

WebAssembly is supported in the current versions of all major browsers.

Interestingly it is also possible to run WebAssembly in Node.js.

Polyglot Functions: Node and WebAssembly

So if we write our functions in a language that can be compiled to WebAssembly, then we should be able to run those functions in Node.js.  Since there is an FDK for Node.js, this means we can leverage the capabilities of the FDK to run our WebAssembly function.

Rust

Rust is a comparatively new language that has generated a lot of interest in the developer community since its launch.  It is statically typed, compiled and fast.  It has generated particular interest from teams who are concerned about memory safety, due to its innovative approach to memory management.

At the time of writing (June 2020) there isn't an FDK for Rust.  However Rust does work with WebAssembly.

Once you have compiled your Rust code to create a WebAssembly package, you can publish this with npm, and use it like a regular JavaScript package.

So we should be able to

1. Write our function code in Rust
2. Create a WebAssembly package
3. Publish the package to npmjs
4. Create a Node.js function in the usual way
5. Reference the WebAssembly package in package.json
6. Call the methods in the package from our JavaScript code in the usual way

To build WebAssembly packages from Rust, we're going to use a tool called wasm-pack.

Building the Function

Setup

To build this example, we need to do the following (if not already installed):

Install Rust

Once Rust is installed, install wasm-pack:

cargo install wasm-pack

Install Node.js

Install the Fn CLI to build functions and deploy them to the Oracle Functions service (preferred) or in a local test environment.  If you're using OCI Cloud Shell the Fn CLI is already installed

You'll need to configure your context for the Fn CLI.  Follow the appropriate instructions for:

• Oracle Functions
• Local Fn

Then create an app to deploy your functions to.

All the code in this sample is available on GitHub.

Create a WebAssembly package with wasm-pack

Run the following command:

$ wasm-pack new rust-fn

Add serialisation support

If we want to be able to serialise and deserialise objects between Rust and JS then we need to modify the Cargo.toml file so that the [dependencies] section matches the example:

	[package]
	name = "rust-fn"
	version = "0.1.0"
	authors = ["Ewan Slater <ewan.slater@gmail.com>"]
	edition = "2018"
	[lib]
	crate-type = ["cdylib", "rlib"]
	[features]
	default = ["console_error_panic_hook"]
	[dependencies]
	wasm-bindgen = { version = "0.2.63", features = ["serde-serialize"] }
	serde = { version = "1.*", features = ["derive"] }
	# The `console_eror_panic_hook` crate provides better debugging of panics by
	# logging them with `console.error`. This is great for development, but requires
	# all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
	# code size when deploying.
	console_error_panic_hook = { version = "0.1.6", optional = true }
	# `wee_alloc` is a tiny allocator for wasm that is only ~1K in code size
	# compared to the default allocator's ~10K. It is slower than the default
	# allocator, however.
	#
	# Unfortunately, `wee_alloc` requires nightly Rust when targeting wasm for now.
	wee_alloc = { version = "0.4.5", optional = true }
	[dev-dependencies]
	wasm-bindgen-test = "0.3.13"
	[profile.release]
	# Tell `rustc` to optimize for small code size.
	opt-level = "s"

view raw rust-fn-cargo.toml hosted with ❤ by GitHub

Expose Rust Functions

Edit the /src/lib.rs file so that it matches the example:

	mod utils;
	use wasm_bindgen::prelude::*;
	use serde::*;
	// When the `wee_alloc` feature is enabled, use `wee_alloc` as the global
	// allocator.
	#[cfg(feature = "wee_alloc")]
	#[global_allocator]
	static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
	#[wasm_bindgen]
	extern {
	#[wasm_bindgen (js_namespace = console)]
	fn log(s: &str);
	}
	#[wasm_bindgen]
	pub fn hello_string(s: &str) -> String {
	format!("Hello, {}!", s)
	}
	#[wasm_bindgen]
	pub fn greet() -> String {
	String::from("Hello, rust-fn!")
	}
	#[derive(Deserialize)]
	pub struct Name {
	pub name: String
	}
	#[derive(Serialize)]
	pub struct Message {
	pub message: String,
	}
	#[wasm_bindgen]
	pub fn greet_json() -> JsValue {
	let msg_string = String::from("Hello, rust-fn!");
	let msg = Message {
	message: msg_string
	};
	JsValue::from_serde(&msg).unwrap()
	}
	#[wasm_bindgen]
	pub fn hello_json(i: &JsValue) -> JsValue {
	let i_name: Name = i.into_serde()
	.unwrap_or_else( |_e| {
	Name { name: "World".to_string() }
	});
	let msg = Message {
	message: format!("Hello, {}!", i_name.name)
	};
	JsValue::from_serde(&msg).unwrap()
	}

view raw rust-fn-lib.rs hosted with ❤ by GitHub

The key here is the annotations

The main one to consider is:

#[wasm_bindgen]

Functions with this annotation will be able to be called from JavaScript.

The other important annotations are:

#[derive(Serialize)]
#[derive(Deserialize)]

These declare the associated type to be serialisable or deserialisable.

There are two styles of function in this example.  The simplest use strings to pass data to and from JavaScript, and the others (with the suffix _json) use JSON and serialization

Compile the Package

Run

wasm-pack build --target nodejs --scope <your-node-js-user-id>

This will create a package that can be used from node, and published to npm.

From the pkg directory, run the following to publish your package:

npm publish --access=public

Creating functions

You can now run fn init in the usual way to create a function:

fn init --runtime node <function-name>

Edit the package.json to include your package (mine is @crush-157/rust-fn)

	{
	"name": "hellofn",
	"version": "1.0.0",
	"description": "example function",
	"main": "func.js",
	"author": "",
	"license": "Apache-2.0",
	"dependencies": {
	"@fnproject/fdk": ">=0.0.18",
	"@crush-157/rust-fn": ">=0.1.0"
	}
	}

view raw rust-fn-package.json hosted with ❤ by GitHub

Then you can reference the package in JavaScript and call it's functions in the usual way.

Sample Functions

There are two sample functions in this example:

lazy-rust

The JSON payload is parsed in JavaScript

	const fdk=require('@fnproject/fdk');
	const wasm=require('@crush-157/rust-fn');
	fdk.handle(function(input){
	let name = 'World';
	if (input.name) {
	name = input.name;
	}
	return {'message': wasm.hello_string(name) }
	})

view raw lazy-rust-fn-func.js hosted with ❤ by GitHub

busy-rust

The JSON payload is parsed by the Rust function

	const fdk=require('@fnproject/fdk');
	const wasm=require('@crush-157/rust-fn');
	fdk.handle(function(input){
	return wasm.hello_json(input);
	})

view raw busy-rust-fn-func.js hosted with ❤ by GitHub

It's up to you whether you'd rather parse JSON in JS and pass it to the function (possibly easier but not terribly elegant), or pass the JSON to Rust and parse it there (maybe a bit more work but cleaner).

So now we can use the Node FDK to run functions written in any language that compiles to WebAssembly.