WasmEdge

https://wasmedge.org/docs
Admin
WasmEdge is a lightweight, portable WebAssembly runtime optimized for cloud-native and edge-native...
Tokens:1,391,839
Snippets:8,538
Trust Score:8.9
Update:7 months ago
Show doc for...
Tokens:
Raw
### Project Setup for WasmEdge Go Example

Source: https://wasmedge.org/docs/zh-TW/embed/go/reference/latest

Commands to initialize a new Go project and download the WasmEdge Go SDK. This is a prerequisite for running the WASM execution example.

```bash
mkdir wasmedge_test && cd wasmedge_test
go mod init wasmedge_test
go get github.com/second-state/WasmEdge-go/wasmedge@v0.14.0
```

--------------------------------

### Install WasmEdge Go SDK

Source: https://wasmedge.org/docs/embed/go/reference/0.12

Provides the command to install the WasmEdge Go SDK using 'go get'. This is a prerequisite for using the WasmEdge Go library in your project.

```bash
go get github.com/second-state/WasmEdge-go/wasmedge@v0.12.1
```

--------------------------------

### Project Setup for WasmEdge Go Example

Source: https://wasmedge.org/docs/zh-tw/embed/go/reference/0.13

Instructions for setting up a new Go project to use the WasmEdge Go API. This includes creating a project directory, initializing Go modules, and obtaining the WasmEdge-go SDK.

```bash
mkdir wasmedge_test && cd wasmedge_test
go mod init wasmedge_test
go get github.com/second-state/WasmEdge-go/wasmedge@v0.13.5
```

--------------------------------

### Install WasmEdge Runtime (Linux)

Source: https://wasmedge.org/docs/start/getting-started/quick_start

Installs the WasmEdge Runtime using a one-liner script. Requires root or sudo privileges and has git and curl as prerequisites. Installs to /usr/local.

```bash
curl -sSf https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install.sh | sudo bash -s -- -p /usr/local  
```

--------------------------------

### Clone Mediapipe Demo Project

Source: https://wasmedge.org/docs/develop/rust/wasinn/mediapipe

Clones the demo project for object detection using Mediapipe and Rust. This is the first step to get started with the provided examples.

```bash
git clone https://github.com/juntao/demo-object-detection
cd demo-object-detection/
```

--------------------------------

### Shell: Setup and Build WasmEdge Go Project

Source: https://wasmedge.org/docs/embed/go/reference/0.11__highlight=wasi&_highlight=api

This shell script demonstrates the commands to set up a new Go project for WasmEdge, initialize it as a Go module, download the WasmEdge Go SDK, build the project, and run the executable.

```bash
mkdir wasmedge_test && cd wasmedge_test
go mod init wasmedge_test
go get github.com/second-state/WasmEdge-go/wasmedge@v0.11.2
go build
./wasmedge_test
```

--------------------------------

### Run Standalone WASM App (WasmEdge CLI)

Source: https://wasmedge.org/docs/start/getting-started/quick_start

Executes a standalone WebAssembly application using the WasmEdge CLI. This example downloads a 'hello.wasm' file and runs it.

```bash
wget https://github.com/second-state/rust-examples/releases/latest/download/hello.wasm  
$ wasmedge hello.wasm  
Hello WasmEdge!  
```

--------------------------------

### Install Kubernetes on Ubuntu

Source: https://wasmedge.org/docs/develop/deploy/kubernetes/kubedge

Installs Kubernetes components (kubelet, kubectl, kubeadm) on Ubuntu systems using apt-get. It adds the Kubernetes repository and pins the versions to prevent automatic updates.

```bash
sudo apt-get update
sudo apt-get install -y apt-transport-https curl
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

sudo apt update
K_VER="1.21.0-00"
sudo apt install -y kubelet=${K_VER} kubectl=${K_VER} kubeadm=${K_VER}
sudo apt-mark hold kubelet kubeadm kubectl
```

--------------------------------

### Setup PyTorch libtorch for WasmEdge WASI-NN (Ubuntu)

Source: https://wasmedge.org/docs/zh-TW/contribute/source/plugin/wasi_nn

This example details how to download and set up the PyTorch C++ distribution (libtorch) on Ubuntu 20.04 for use with the WasmEdge WASI-NN PyTorch backend. It includes setting environment variables for the build process.

```bash
export PYTORCH_VERSION="1.8.2"
curl -s -L -O --remote-name-all https://download.pytorch.org/libtorch/lts/1.8/cpu/libtorch-cxx11-abi-shared-with-deps-${PYTORCH_VERSION}%2Bcpu.zip
unzip -q "libtorch-cxx11-abi-shared-with-deps-${PYTORCH_VERSION}%2Bcpu.zip"
rm -f "libtorch-cxx11-abi-shared-with-deps-${PYTORCH_VERSION}%2Bcpu.zip"
export LD_LIBRARY_PATH=$(pwd)/libtorch/lib:${LD_LIBRARY_PATH}
export Torch_DIR=$(pwd)/libtorch
```

--------------------------------

### Install WasmEdge (Shell)

Source: https://wasmedge.org/docs/develop/deploy/kubernetes/superedge

Installs WasmEdge on an edge node using a simple install script fetched from GitHub. This script automates the download and setup process for WasmEdge.

```shell
curl -sSf https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install.sh | bash  
```

--------------------------------

### Setup KubeEdge Master Node

Source: https://wasmedge.org/docs/develop/deploy/kubernetes/kubedge

Installs KubeEdge on the master node. This involves downloading the `keadm` binary, extracting it, and initializing the KubeEdge cloud core with the specified advertise address and kubeconfig path.

```bash
wget https://github.com/kubeedge/kubeedge/releases/download/v1.8.0/keadm-v1.8.0-linux-amd64.tar.gz
tar xzvf keadm-v1.8.0-linux-amd64.tar.gz
cd keadm-v1.8.0-linux-amd64/keadm/
sudo ./keadm init --advertise-address=192.168.122.160 --kube-config=/home/${user}/.kube/config
```

--------------------------------

### Install Go on Linux

Source: https://wasmedge.org/docs/develop/deploy/kubernetes/kubedge

Installs Go version 1.17.3 on a Linux amd64 system by downloading the archive, extracting it, and updating the PATH environment variable. It also verifies the installation by printing the Go version.

```bash
$ wget https://golang.org/dl/go1.17.3.linux-amd64.tar.gz  
$ tar xzvf go1.17.3.linux-amd64.tar.gz  

$ export PATH=/home/${user}/go/bin:$PATH  
$ go version  
go version go1.17.3 linux/amd64  

```

--------------------------------

### Install WasmEdge on Windows using winget

Source: https://wasmedge.org/docs/start/install

Installs the WasmEdge runtime on Windows 10 using the Windows Package Manager client (`winget.exe`). This is a straightforward command to get the WasmEdge runtime installed.

```powershell
winget install wasmedge  

```

--------------------------------

### Go SDK: Installation and Build

Source: https://wasmedge.org/docs/embed/go/passing_data

These commands outline the process for setting up the WasmEdge Go SDK and building the example application. It involves fetching the SDK package and then compiling the Go source file.

```shell
go get github.com/second-state/WasmEdge-go/wasmedge@v0.14.0
go build run.go

```

--------------------------------

### Install WasmEdge Rustls Plug-in

Source: https://wasmedge.org/docs/contribute/source/plugin/rusttls

Installs the built WasmEdge Rustls plug-in into your Rust binary directory using the 'cargo install' command.

```bash
cargo install --path .
```

--------------------------------

### Initialize Go Project for WasmEdge

Source: https://wasmedge.org/docs/embed/go/reference/0.9

This snippet shows how to set up a new Go project for WasmEdge development. It includes creating a directory, initializing a Go module, and installing the WasmEdge Go SDK.

```bash
mkdir wasmedge_test && cd wasmedge_test
go mod init wasmedge_test
go get github.com/second-state/WasmEdge-go/wasmedge@v0.9.2
```

--------------------------------

### Install Containerd

Source: https://wasmedge.org/docs/zh/develop/deploy/cri-runtime/containerd-crun

Installs containerd version 1.5.7 on a Debian-based system. It downloads the necessary binaries, verifies their integrity using SHA256 checksums, and installs them. Dependencies like libseccomp2 and wget are also installed.

```shell
export VERSION="1.5.7"
 echo -e "Version: $VERSION"
 echo -e "Installing libseccomp2 ..."
 sudo apt install -y libseccomp2
 echo -e "Installing wget"
 sudo apt install -y wget
 
wget https://github.com/containerd/containerd/releases/download/v${VERSION}/cri-containerd-cni-${VERSION}-linux-amd64.tar.gz
wget https://github.com/containerd/containerd/releases/download/v${VERSION}/cri-containerd-cni-${VERSION}-linux-amd64.tar.gz.sha256sum
sha256sum --check cri-containerd-cni-${VERSION}-linux-amd64.tar.gz.sha256sum

sudo tar --no-overwrite-dir -C / -xzf cri-containerd-cni-${VERSION}-linux-amd64.tar.gz
sudo systemctl daemon-reload
```

--------------------------------

### Run WebAssembly Functions with WasmEdge Go SDK

Source: https://wasmedge.org/docs/zh-tw/embed/go/bindgen

This Go code demonstrates how to use the WasmEdge Go SDK to load and execute WebAssembly functions. It initializes a WasmEdge VM, sets up WASI, and then uses the wasmedge-bindgen library to call functions like `create_line`, `say`, `obfusticate`, `lowest_common_multiple`, `sha3_digest`, and `keccak_digest` with various data types. Dependencies include the WasmEdge Go SDK and the wasmedge-bindgen Go library.

```go
package main  
  
import (  
  "fmt"
  "os"
  
  "github.com/second-state/WasmEdge-go/wasmedge"
  bindgen "github.com/second-state/wasmedge-bindgen/host/go"
)

func main() {
  // Expected Args[0]: program name (./bindgen_funcs)  
  // Expected Args[1]: wasm or wasm-so file (rust_bindgen_funcs_lib.wasm))

  // Set not to print debug info  
  wasmedge.SetLogErrorLevel()

  // Create configure  
  var conf = wasmedge.NewConfigure(wasmedge.WASI)

  // Create VM with configure  
  var vm = wasmedge.NewVMWithConfig(conf)

  // Init WASI  
  var wasi = vm.GetImportModule(wasmedge.WASI)
  wasi.InitWasi(
    os.Args[1:],     // The args
    os.Environ(),    // The envs
    []string{'.', '.', '.'}, // The mapping preopens
  )

  vm.LoadWasmFile(os.Args[1])
  vm.Validate()
  // Instantiate the bindgen and vm  
  bg := bindgen.New(vm)
  bg.Instantiate()

  // Run bindgen functions  
  var res []interface{}
  var err error
  // create_line: array, array, array -> array (inputs are JSON stringified)
  res, _, err = bg.Execute("create_line", "{\"x\":1.5,\"y\":3.8}", "{\"x\":2.5,\"y\":5.8}", "A thin red line")
  if err == nil {
    fmt.Println("Run bindgen -- create_line:", res[0].(string))
  } else {
    fmt.Println("Run bindgen -- create_line FAILED")
  }
  // say: array -> array
  res, _, err = bg.Execute("say", "bindgen funcs test")
  if err == nil {
    fmt.Println("Run bindgen -- say:", res[0].(string))
  } else {
    fmt.Println("Run bindgen -- say FAILED")
  }
  // obfusticate: array -> array
  res, _, err = bg.Execute("obfusticate", "A quick brown fox jumps over the lazy dog")
  if err == nil {
    fmt.Println("Run bindgen -- obfusticate:", res[0].(string))
  } else {
    fmt.Println("Run bindgen -- obfusticate FAILED")
  }
  // lowest_common_multiple: i32, i32 -> i32
  res, _, err = bg.Execute("lowest_common_multiple", int32(123), int32(2))
  if err == nil {
    fmt.Println("Run bindgen -- lowest_common_multiple:", res[0].(int32))
  } else {
    fmt.Println("Run bindgen -- lowest_common_multiple FAILED")
  }
  // sha3_digest: array -> array
  res, _, err = bg.Execute("sha3_digest", []byte("This is an important message"))
  if err == nil {
    fmt.Println("Run bindgen -- sha3_digest:", res[0].([]byte))
  } else {
    fmt.Println("Run bindgen -- sha3_digest FAILED")
  }
  // keccak_digest: array -> array
  res, _, err = bg.Execute("keccak_digest", []byte("This is an important message"))
  if err == nil {
    fmt.Println("Run bindgen -- keccak_digest:", res[0].([]byte))
  } else {
    fmt.Println("Run bindgen -- keccak_digest FAILED")
  }

  bg.Release()
  conf.Release()
}

```

--------------------------------

### Install Rust Programming Language

Source: https://wasmedge.org/docs/develop/rust/setup

Installs the Rust programming language and its package manager, Cargo, using the official installation script. This is necessary for developing Rust applications.

```shell
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

--------------------------------

### Create VM and Get Store (Go)

Source: https://wasmedge.org/docs/zh-tw/embed/go/reference/0.13

Demonstrates creating a WasmEdge VM and retrieving its associated Store object. It shows two methods: one where the VM allocates its own Store, and another where a pre-existing Store is provided to the VM. It also highlights memory management considerations for the Store object.

```go
vm := wasmedge.NewVM()
store := vm.GetStore()
// The object should __NOT__ be deleted by calling `(*Store).Release`.
v.Release()
```

```go
store := wasmedge.NewStore()
vm := wasmedge.NewVMWithStore(store)

storemock := vm.GetStore()
// The internal store context of the `store` and the `storemock` are the same.

v.Release()
store.Release()
```

--------------------------------

### Rust Reqwest HTTP GET Request Example for WasmEdge

Source: https://wasmedge.org/docs/develop/rust/http_service/client

An example Rust code snippet demonstrating an asynchronous HTTP GET request using the `reqwest` crate in WasmEdge. It fetches IP information from `http://eu.httpbin.org/ip` and parses the JSON response.

```rust
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::get("http://eu.httpbin.org/ip")
        .await? 
        .json::<HashMap<String, String>>()
        .await?;
    println!("{:#?}", resp);
    Ok(())
}
```

--------------------------------

### Install WasmEdge V2 using curl

Source: https://wasmedge.org/docs/contribute/installer_v2

This command downloads and executes the WasmEdge V2 installer script from a GitHub URL using curl. It allows for various options to customize the installation. Dependencies include curl and tar.

```shell
curl -sSf https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install_v2.sh | bash -s -- ${OPTIONS}
```

--------------------------------

### Build and Run Go Application

Source: https://wasmedge.org/docs/embed/go/reference/0.9

This snippet shows the commands to build and run the Go application created in the previous step. It first installs the WasmEdge Go SDK, then builds the Go program, and finally executes the compiled binary.

```bash
go build
./wasmedge_test
```

--------------------------------

### WASI Initialization (0.10.0 C API)

Source: https://wasmedge.org/docs/zh/embed/c/reference/upgrade_to_0.10

Example of initializing WASI using the WasmEdge 0.10.0 C API, replacing ImportObjectContext with ModuleInstanceContext.

```APIDOC
## WASI Initialization (0.10.0 C API)

### Description
This example demonstrates how to initialize WASI in WasmEdge version 0.10.0 using the C API. It is similar to the 0.9.1 version but replaces `WasmEdge_ImportObjectContext` with `WasmEdge_ModuleInstanceContext`.

### Method
N/A (Code Example)

### Endpoint
N/A (Code Example)

### Parameters
N/A (Code Example)

### Request Example
```c
WasmEdge_ConfigureContext *ConfCxt = WasmEdge_ConfigureCreate();
WasmEdge_ConfigureAddHostRegistration(ConfCxt, WasmEdge_HostRegistration_Wasi);
WasmEdge_VMContext *VMCxt = WasmEdge_VMCreate(ConfCxt, NULL);
/* The following API can retrieve the pre-registration module instances from the VM context. */
/* This API will return `NULL` if the corresponding pre-registration is not set into the configuration. */
WasmEdge_ModuleInstanceContext *WasiModule =
    WasmEdge_VMGetImportModuleContext(VMCxt, WasmEdge_HostRegistration_Wasi);
/* Initialize the WASI. */
WasmEdge_ModuleInstanceInitWASI(WasiModule, /* ... ignored */ );

/* ... */

WasmEdge_VMDelete(VMCxt);
WasmEdge_ConfigureDelete(ConfCxt);
```

### Response
N/A (Code Example)

### Response Example
N/A (Code Example)
```

--------------------------------

### Install ChatTTS Dependencies for WasmEdge

Source: https://wasmedge.org/docs/zh/contribute/source/plugin/wasi_nn

Installs the necessary Python dependencies for the ChatTTS backend of WasmEdge. This includes updating package lists, upgrading existing packages, installing Python development headers, and installing the chattts Python library.

```bash
sudo apt update
sudo apt upgrade
sudo apt install python3-dev
pip install chattts==0.1.1
```

--------------------------------

### Clone WasmEdge WASI-NN Examples Repository

Source: https://wasmedge.org/docs/develop/rust/wasinn/whisper

This command clones the WasmEdge WASI-NN examples repository, which contains the Whisper basic example. Ensure you have Git installed to use this command.

```shell
git clone https://github.com/second-state/WasmEdge-WASINN-examples.git  
cd WasmEdge-WASINN-examples/whisper-basic/
```

--------------------------------

### Create and Register WASI and WasmEdge Process Modules in Go

Source: https://wasmedge.org/docs/embed/go/reference/0.11__highlight=wasi&_highlight=api

Demonstrates creating and registering WASI and WasmEdge Process module instances into a WasmEdge VM. It shows how to initialize these modules with arguments, environment variables, preopens, and allowed commands, and how to retrieve the WASI exit code after execution. The example also covers releasing the module and VM resources.

```Go
wasiobj := wasmedge.NewWasiModule(  
  os.Args[1:],     // The args  
  os.Environ(),    // The envs  
  []string{”.:.”}, // The mapping preopens  
)
procobj := wasmedge.NewWasmEdgeProcessModule(  
  []string{“ls”, “echo”}, // The allowed commands  
  false,                  // Not to allow all commands  
)

// Register the WASI and WasmEdge_Process into the VM object.  
vm := wasmedge.NewVM()
vm.RegisterImport(wasiobj)
vm.RegisterImport(procobj)

// ... Execute some WASM functions.  

// Get the WASI exit code.  
exitcode := wasiobj.WasiGetExitCode()
// The `exitcode` will be 0 if the WASI function "_start" execution has no error.  
// Otherwise, it will return with the related exit code.  

vm.Release()
// The import objects should be deleted.  
wasiobj.Release()
procobj.Release()

```

--------------------------------

### Install WasmEdge Runtime

Source: https://wasmedge.org/docs/develop/rust/setup

Installs the WasmEdge runtime on your machine using a provided shell script. This is a prerequisite for running WasmEdge applications.

```shell
curl -sSf https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install.sh | bash
```

--------------------------------

### Initialize WASI with ImportObject (WasmEdge-Go v0.9.2)

Source: https://wasmedge.org/docs/zh/embed/go/reference/upgrade_to_0.10

Demonstrates WASI initialization using the ImportObject API in WasmEdge-Go version 0.9.2. It shows how to create a configuration, instantiate a VM, retrieve the WASI import object, and initialize it with arguments, environment variables, and preopens.

```go
conf := wasmedge.NewConfigure(wasmedge.WASI)
vm := wasmedge.NewVMWithConfig(conf)

// The following API can retrieve the pre-registration import objects from the VM object.
// This API will return `nil` if the corresponding pre-registration is not set into the configuration.
wasiobj := vm.GetImportObject(wasmedge.WASI)
// Initialize the WASI.
wasiobj.InitWasi(
  os.Args[1:],     // The args
  os.Environ(),    // The envs
  []string{'.':'.'}, // The mapping preopens
)

// ...

vm.Release()
conf.Release()
```

--------------------------------

### Create and Register WASI and WasmEdge Process Modules in Go

Source: https://wasmedge.org/docs/embed/go/reference/0.10

Demonstrates creating WASI and WasmEdge Process module instances and registering them into a WasmEdge VM. It shows how to set arguments, environment variables, preopens, and allowed commands for the modules. The example also covers retrieving the WASI exit code and releasing module resources.

```Go
package main

import (
  "fmt"
  "os"

  "github.com/second-state/WasmEdge-go/wasmedge"
)

func main() {
  // Create WASI module instance
  wasiobj := wasmedge.NewWasiModule(
    os.Args[1:],     // The args
    os.Environ(),    // The envs
    []string{'.': '.'}, // The mapping preopens
  )
  // Create WasmEdge Process module instance
  procobj := wasmedge.NewWasmEdgeProcessModule(
    []string{"ls", "echo"}, // The allowed commands
    false,                  // Not to allow all commands
  )

  // Register the WASI and WasmEdge_Process into the VM object.
  vm := wasmedge.NewVM()
  vm.RegisterImport(wasiobj)
  vm.RegisterImport(procobj)

  // ... Execute some WASM functions.

  // Get the WASI exit code.
  exitcode := wasiobj.WasiGetExitCode()
  // The `exitcode` will be 0 if the WASI function "_start" execution has no error.
  // Otherwise, it will return with the related exit code.

  vm.Release()
  // The import objects should be deleted.
  wasiobj.Release()
  procobj.Release()
}
```

--------------------------------

### Install WasmEdge Core Tools and Extensions using Shell Script

Source: https://wasmedge.org/docs/contribute/installer

This command downloads and executes the WasmEdge installer script. It allows for customization through various options passed as arguments. The script handles the installation of core tools, libraries, extensions like TensorFlow, and plugins.

```shell
curl -sSf https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install.sh | bash -s -- ${OPTIONS}
```

--------------------------------

### Set up Kubernetes Cluster (1.18.9)

Source: https://wasmedge.org/docs/zh/develop/deploy/kubernetes/openyurt

Installs Kubernetes components (kubelet, kubeadm, kubectl) version 1.18.9 on a Debian-based system. It configures the system to use a specific Kubernetes APT repository and initializes the master node with a specified pod network CIDR and image repository. It also provides the command to join a worker node to the cluster.

```bash
sudo apt-get update && sudo apt-get install -y ca-certificates curl software-properties-common apt-transport-https
# add K8s source
curl -s https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg | sudo apt-key add -
sudo tee /etc/apt/sources.list.d/kubernetes.list <<EOF
$ deb https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial main
# install K8s components 1.18.9
sudo apt-get update && sudo apt-get install -y kubelet=1.18.9-00 kubeadm=1.18.9-00 kubectl=1.18.9-00
# Initialize the master node
sudo kubeadm init --pod-network-cidr=172.16.0.0/16 \
--apiserver-advertise-address=192.168.3.167 \
--image-repository registry.cn-hangzhou.aliyuncs.com/google_containers
# join the work node
kubeadm join 192.168.3.167:6443 --token 3zefbt.99e6denc1cxpk9fg \
   --discovery-token-ca-cert-hash sha256:8077d4e7dd6eee64a999d56866ae4336073ed5ffc3f23281d757276b08b9b195
```
Tokens:
Raw