การสร้างและเรียกใช้โมดูล WASI

Welcome back! In the previous lesson, we learned what WASI is and its goals. Now, let's get practical.

This lesson focuses on the hands-on process of compiling Rust code to target WASI and then executing your WebAssembly modules in various WASI runtimes.

Rust is a prime language for WASI development due to its performance, safety features, and strong support for WebAssembly. To get started, you'll need:

• Rust Toolchain: Install it via rustup if you haven't already.
• WASI Target: Add the specific WASI compilation target.

We'll use Cargo, Rust's official package manager and build system, to create a new project. This sets up the basic directory structure.

Let's write a simple Rust program. For WASI, basic I/O operations like printing to the console are handled through the WASI API. Open src/main.rs and add this code:

When you use println! in a standard Rust program, it interacts directly with the operating system. For WASI, things are a bit different.

• The WASM module is sandboxed.
• println! calls are routed through the WASI API.
• WASI provides a standardized interface for basic system functions like console output, file access, and environment variables.

Now, let's compile our Rust code into a WebAssembly module specifically for the WASI target. This command tells Cargo to use the wasm32-wasi target we added earlier.

After successful compilation, you'll find your WASI WebAssembly module. It's a standalone binary file, ready for execution!

Look in the target/wasm32-wasi/debug/ directory for a file named my-wasi-app.wasm. This is your compiled WASI module.

To execute a WASI module, you need a WASI runtime. Wasmtime is a popular, high-performance runtime designed for this purpose.

• Install Wasmtime: Follow instructions on wasmtime.dev for your OS.
• Run your module: Execute the .wasm file using the wasmtime command.

WASI allows controlled access to the host's file system. Let's modify our Rust program to read from a file. Remember, you'll need to explicitly grant Wasmtime permission to access files.

After updating src/main.rs, compile again. Then, you'll need to create an input.txt file in your project root with some content. Finally, run it with Wasmtime, granting directory access:

Let's test your understanding of building and running WASI modules.

In this lesson, we explored the practical steps of building and running WebAssembly modules with WASI.

• We set up our Rust environment for the wasm32-wasi target.
• We wrote Rust code that leverages WASI for system interactions.
• We compiled our code into a portable .wasm module.
• We learned how to execute these modules using a WASI runtime like Wasmtime, including granting necessary permissions for host resource access.

Next, we'll delve deeper into WASI's capabilities and its implications for secure and portable applications.