{"id":16467,"date":"2021-04-14T14:00:21","date_gmt":"2021-04-14T14:00:21","guid":{"rendered":"https:\/\/training.linuxfoundation.org\/?p=16467"},"modified":"2021-05-13T21:25:01","modified_gmt":"2021-05-13T21:25:01","slug":"using-web-assembly-written-in-rust-on-the-server-side","status":"publish","type":"post","link":"https:\/\/training.linuxfoundation.org\/ja\/blog\/using-web-assembly-written-in-rust-on-the-server-side\/","title":{"rendered":"\u30b5\u30fc\u30d0\u30fc\u5074\u3067Rust\u3067\u8a18\u8ff0\u3055\u308c\u305fWeb\u30a2\u30bb\u30f3\u30d6\u30ea\u3092\u4f7f\u7528\u3059\u308b"},"content":{"rendered":"

By Bob Reselman<\/em><\/p>\n

This article was originally published at TheNewStac<\/a><\/em>k<\/em><\/p>\n

WebAssembly allows you to write code in a low-level programming language such as Rust, that gets compiled into a transportable binary. That binary can then be run on the client-side in the WebAssembly virtual machine that is\u00a0standard in today\u2019s web browsers<\/a>. Or, the binary can be used on the server-side, as a component consumed by another programming framework \u2014 such as Node.js or\u00a0Deno<\/a>.<\/p>\n

WebAssembly combines the efficiency inherent in low-level code programming with the ease of component transportability typically found in Linux containers. The result is a development paradigm specifically geared toward doing computationally intensive work at scale \u2014 for example, artificial intelligence and complex machine learning tasks.<\/p>\n

As Solomon Hykes, the creator of Docker,\u00a0tweeted<\/a> on March 27, 2019: \u201cIf WASM+WASI existed in 2008, we wouldn\u2019t have needed to have created Docker. That\u2019s how important it is. WebAssembly on the server is the future of computing.\u201d<\/p>\n

WebAssembly is a compelling approach to software development. However, in order to get a true appreciation for the technology, you need to see it in action.<\/p>\n

In this article, I am going to show you how to program a WebAssembly binary in Rust and use it in a TypeScript-powered web server running under Deno. I\u2019ll show you how to install Rust and prep the runtime environment. We\u2019ll compile the source code into a Rust binary. Then, once the binary is created, I\u2019ll demonstrate how to run it on the server-side under\u00a0Deno<\/a>. Deno is a TypeScript-based programming framework that was started by Ryan Dahl, the creator of Node.js.<\/p>\n

Understanding the Demonstration Project<\/h2>\n

The demonstration project that accompanies this article is called Wise Sayings. The project stores a collection of \u201cwise sayings\u201d in a text file named wisesayings.txt. Each line in the text file is a wise saying, for example, \u201cA friend in need is a friend indeed.<\/em>\u201d<\/p>\n

The Rust code publishes a single function, get_wise_saying(). That function gets a random line from the text file, wisesayings.txt, and returns the random line to the caller. (See Figure 1, below)<\/p>\n

\n

\"\"<\/a><\/p>\n

Figure 1: The demonstration project compiles data in a text file directly into the WebAssembly binary<\/p>\n<\/div>\n

Both the code and text file are compiled into a single WebAssembly binary file, named wisesayings.wasm. Then another layer of processing is performed to make the WebAssembly binary consumable by the Deno web server code. The Deno code calls the function get_wise_sayings() in the WebAssembly binary, to produce a random wise saying. (See Figure 2.)<\/p>\n

\n

\"\"<\/a><\/p>\n

Figure 2: WebAssembly binaries can be consumed by a server-side programming framework such as Deno.<\/p>\n<\/div>\n

You get the source code for the Wise Sayings demonstration project used in this article\u00a0on GitHub<\/a>. All the steps described in this article are listed on the repository\u2019s main\u00a0Readme<\/a>\u00a0document.<\/em><\/p>\n

Prepping the Development Environment<\/h2>\n

The first thing we need to do to get the code up and running is to make sure that Rust is installed in the development environment. The following steps describe the process.<\/p>\n

Step 1:\u00a0<\/strong>Make sure Rust is installed on your machine by typing:<\/p>\n

<\/div>\n

\"\"<\/p>\n

You\u2019ll get output similar to the following:<\/p>\n

<\/div>\n

\"\"<\/p>\n

If the call to rustc \u2013version fails, you don\u2019t have Rust installed. Follow the instructions below and\u00a0make sure you do all the tasks presented by the given installation method<\/strong>.<\/p>\n

To install Rust, go here and install on Linux\/MAC: \u2026<\/p>\n

\n
\"\"<\/div>\n<\/div>\n

\u2026 or here to install it on Windows:<\/p>\n

Download and run rustup-init.exe which you can find at this URL: https:\/\/static.rust-lang.org\/rustup\/dist\/i686-pc-windows-gnu\/rustup-init.exe.<\/p>\n

Step 2:<\/strong>\u00a0Modify your system\u2019s PATH<\/p>\n

\n
\"\"<\/div>\n<\/div>\n

Step 3:\u00a0<\/strong>If you\u2019re working in a Linux environment do the following steps to install the required additional Linux components.<\/p>\n

\n
\"\"<\/div>\n<\/div>\n

Developer\u2019s Note:\u00a0<\/strong>The optimal development environment in which to run this code is one that uses the Linux operating system.<\/em><\/p>\n

Step 4:\u00a0<\/strong>Get the CLI tool that you\u2019ll use for generating the TypeScript\/JavaScript adapter files. These adapter files (a.k.a. shims) do the work of exposing the function get_wise_saying() in the WebAssembly binary to the Deno web server that will be hosting the binary. Execute the following command at the command line to install the tool,\u00a0wasm-bindgen-cli<\/a>.<\/p>\n

\n
\"\"<\/div>\n<\/div>\n

The development environment now has Rust installed, along with the necessary ancillary libraries. Now we need to get the Wise Saying source code.<\/p>\n

Working with the Project Files<\/h2>\n

The Wise Saying source code is hosted in a GitHub repository. Take the following steps to clone the source code from GitHub onto the local development environment.<\/p>\n

Step 1:\u00a0<\/strong>Execute the following command to clone the Wise Sayings source code from GitHub<\/p>\n

\n
\"\"<\/div>\n<\/div>\n

Step 2:\u00a0<\/strong>Go to the working directory<\/p>\n

\n
\"\"<\/div>\n<\/div>\n

Listing 1, below lists the files that make up the source code cloned from the GitHub repository.<\/p>\n

\n
\"\"<\/div>\n<\/div>\n

Listing 1: The files for the source code for the Wise Sayings demonstration project hosted in the GitHub repository<\/em><\/p>\n

Let\u2019s take a moment to describe the source code files listed above in Listing 1. The particular files of interest with regard to creating the WebAssembly binary are the files in the directory named, src at Line 11 and the file, Cargo.toml at Line 2.<\/p>\n

Let\u2019s discuss Cargo.toml first. The content of Cargo.toml is shown in Listing 2, below.<\/p>\n

\n
\"\"<\/div>\n<\/div>\n

Listing 2: The content of Cargo.toml for the demonstration project Wise Sayings<\/em><\/p>\n

Cargo.toml is the\u00a0manifest file<\/a>\u00a0that describes various aspects of the Rust project under development. The Cargo.toml file for the Wise Saying project is organized into three sections: package, dependencies, and lib. The section names are defined in the Cargo manifest specification, which you read\u00a0here<\/a>.<\/p>\n

Understanding the Package Section of Cargo.toml<\/h3>\n

The package section indicates the name of the package (wise-sayings-wasm), the developer assigned version (0.1.0), the authors (Bob Reselman <bob@CogArtTech.com<\/a>>) and the edition of Rust (2018) that is used to program the binary.<\/p>\n

Understanding the Dependencies Section of Cargo.toml<\/h3>\n

The dependencies section lists the dependencies that the WebAssembly project needs to do its work. As you can see in Listing 2, above at Line 8, the Cargo.toml lists the rand library as a dependency. The rand library provides the capability to generate a random number which is used to get a random line of wise saying text from the file, wisesayings.txt.<\/p>\n

The reference to getrandom at Line 9 in Listing 2 above indicates that the WebAssembly binary\u2019s\u00a0getrandom<\/a>\u00a0is running under Javascript and that the\u00a0JavaScript interface should be used<\/a>. This condition is very particular to running a WebAssembly binary under JavaScript. The long and short of it is that if the line getrandom = { version = \u201c0.2\u201d, features = [\u201cjs\u201d] } is not included in the Cargo.toml, the WebAssembly binary will not be able to create a random number.<\/p>\n

The entry at Line 10 declares the\u00a0wasm-bindgen<\/a>\u00a0library as a dependency. The wasm-bindgen library provides the capability for wasm modules to talk to JavaScript and JavaScript to talk to wasm modules.<\/p>\n

Understanding the Lib Section of Cargo.toml<\/h3>\n

The entry\u00a0crate-type =[\u201ccdylib\u201d, \u201clib\u201d]<\/a>\u00a0at Line 14 in the lib section of the Cargo.toml file tells the Rust compiler to create a wasm binary without a start function. Typically when cdylib is indicated, the compiler will create a\u00a0dynamic library<\/a>\u00a0with the extension .dll in Windows, .so in Linux, or .dylib in MacOS. In this case, because the deployment unit is a WebAssembly binary, the compiler will create a file with the extension .wasm. The name of the wasm file will be wisesayings.wasm, as indicated at Line 13 above in Listing 2.<\/p>\n

The important thing to understand about Cargo.toml is that it provides both the design and runtime information needed to get your Rust code up and running. If the Cargo.toml file is not present, the Rust compiler doesn\u2019t know what to do and the build will fail.<\/p>\n

Understanding the Core Function, get_wise_saying()<\/h2>\n

The actual work of getting a random line that contains a Wise Saying from the text file wisesayings.txt is done by the function get_wise_saying(). The code for get_wise_sayings() is in the Rust library file, .\/src\/lib.rs. The Rust code is shown below in Listing 3.<\/p>\n

\n
\"\"<\/div>\n<\/div>\n

Listing 3: The function file, lib.rs contains the function, get_wise_saying().<\/em><\/p>\n

The important things to know about the source is that it\u2019s tagged at Line 4 with the attribute #[wasm_bindgen], which lets the Rust compiler know that the source code is targeted as a WebAssembly binary. The code publishes one function, get_wise_saying(), at Line 5. The way the wise sayings text file is loaded into memory is to use the\u00a0Rust macro<\/a>,\u00a0include_str!<\/a>. This macro does the work of getting the file from disk and loading the data into memory. The macro loads the file as a string and the function str.lines() separates the lines within the string into an array. (Line 7.)<\/p>\n

The rand::thread_rng() call at Line 10 returns a number that is used as an index by the .choose() function at Line 10. The result of it all is an array of characters (a string) that reflects the wise saying returned by the function.<\/p>\n

Creating the WebAssembly Binary<\/h2>\n

Let\u2019s move on to creating the Wasm target and compiling the code into a WebAssembly Binary.<\/p>\n

Step 1:<\/strong> Add the binary target.<\/p>\n

\"\"<\/strong><\/p>\n

Step 2: <\/strong>Compile the source code into a WebAssembly is shown below.<\/p>\n

\n
\"\"<\/div>\n<\/div>\n

WHERE<\/p>\n