Rust Development Setup§

Let’s start by installing the Rust ecosystem, if not already done. At the time of writing, Rust 1.76 is the latest stable version. To install Rust, see the instructions on their website.

After the installation completes, you can confirm the current version of Rust by running:

$ rustc -V
rustc 1.76.0 (07dca489a 2024-02-04)

To work with Wasm Components, we need some additional tooling. This is a one-time setup for you to be able to write Rust source code and compile it to a Wasm Component.

Add the wasm32-wasi compiler target§

The wasm32-wasi compiler target will provide general Wasm support to your rustc installation. Add the target by running:

$ rustup target add wasm32-wasi

Install cargo-component§

cargo-component will add a cargo subcommand to build Wasm Components without any intermediate steps from our Rust project. To install the latest version, run the following command:

$ cargo install cargo-component

Install wasmtime runtime and CLI for testing§

The wasmtime-cli will be used to test and play around with the Wasm component. At the time of writing, we are using Wasmtime 18. To install the latest version of Wasmtime, run:

$ curl https://wasmtime.dev/install.sh -sSf | bash

For more information about Wasmtime and installing it, see their GitHub repository

Once we have all the tools in place, we can create the Rust projects.

Using the wasi Rust library§

Our experience with the official WASI Rust library was very interesting and exciting. The component build time was fascinating, and the library has a low dependency footprint. However, there are some costs in terms of developer experience. See for yourselves:

Start by creating a new Wasm Component using cargo component:

$ cargo component new --lib test-wasi-component

Navigate into the test-wasi-component directory.

Add the wasi crate:

$ cargo add wasi

Next, modify the Cargo.toml file with the text editor of your choice. Add the proxy = true configuration to the [package.metadata.component] section. After saving the changes, your Cargo.toml file should look like this:

[package]
name = "test-wasi-component"
version = "0.1.0"
edition = "2021"

[dependencies]
bitflags = "2.4.2"
wit-bindgen-rt = "0.21.0"
wasi = "0.13.0"

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

[package.metadata.component]
package = "component:test-wasi-component"
proxy = true

[package.metadata.component.dependencies]

The actual code from src/lib.rs should look like this:

use wasi::http::types::{
   Fields, IncomingRequest, OutgoingBody, OutgoingResponse, ResponseOutparam,
};

wasi::http::proxy::export!(Component);

struct Component;

impl wasi::exports::http::incoming_handler::Guest for Component {
   fn handle(_request: IncomingRequest, response_out: ResponseOutparam) {

      let hdrs = Fields::new();
      let mesg = String::from("Hello, This is a Wasm Component using wasi/http:proxy!");
      let _try = hdrs.set(&"Content-Type".to_string(), &[b"plain/text".to_vec()]);
      let _try = hdrs.set(&"Content-Length".to_string(), &[mesg.len().to_string().as_bytes().to_vec()]);

      let resp = OutgoingResponse::new(hdrs);

      // Add the HTTP Response Status Code
      resp.set_status_code(200).unwrap();

      let body = resp.body().unwrap();
      ResponseOutparam::set(response_out, Ok(resp));

      let out = body.write().unwrap();
      out.blocking_write_and_flush(mesg.as_bytes()).unwrap();
      drop(out);

      OutgoingBody::finish(body, None).unwrap();
   }
}

Targeting the wasi crate requires some low-level Rust work by us. Not bad at all, but something to consider when choosing this option. For the wasi:http/proxy world there is an interface description available on GitHub which will help to write your code.

Let’s build the component. Run the following command from the test-wasi-component directory:

$ cargo component build --release

The build shows a very small dependency footprint, so is a major benefit from the wasi crate.

To test the Component, we can use wasmtime serve.

$ wasmtime serve target/wasm32-wasi/release/test_wasi_component.wasm

The output should look like the following:

$ wasmtime serve target/wasm32-wasi/release/test_wasi_component.wasm
  Serving HTTP on http://0.0.0.0:8080/

Sending a request to the exposed endpoint will output something like this:

$ curl -v localhost:8080
…
> GET / HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/8.4.0
> Accept: */*
>
< HTTP/1.1 200 OK
< content-type: plain/text
< content-length: 54
< date: Tue, 12 Mar 2024 12:28:56 GMT
<
* Connection #0 to host localhost left intact
Hello, This is a Wasm Component using wasi/http:proxy!