Runtimes Host WASI: wasmtime, wazero & Spin

Um binário wasip1/wasm é apenas metade da história.

Algo deve instanciar o módulo, satisfazer importações WASI e, opcionalmente, mapear gatilhos HTTP ou capacidades do sistema de arquivos.

wasmtime, wazero e Spin são os três hosts que as equipes Go procuram primeiro - ferramentas CLI, incorporação in-process e HTTP na edge, respectivamente.

Resumo

Compile Go com GOOS=wasip1 GOARCH=wasm, depois execute o artefato através de um host que fala WASI Preview 1.

wasmtime se destaca no desenvolvimento local e scripting.

wazero se encaixa em microsserviços Go que carregam plugins in-process.

Spin empacota manipuladores HTTP opinativos para implantações de edge no estilo Fermyon.

Cada host difere em como concede capacidades de sistema de arquivos, ambiente e rede.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

# Loop de desenvolvimento
GOOS=wasip1 GOARCH=wasm go build -o app.wasm .
wasmtime run --env APP_ENV=dev --dir .::/work app.wasm

// Incorporar com wazero (host Go)
wasi_snapshot_preview1.MustInstantiate(ctx, runtime)
mod, _ := runtime.Instantiate(ctx, wasmBytes)
_, _ = mod.ExportedFunction("_start").Call(ctx)

Quando usar isso:

• Plugins em sandbox dentro de uma API Go existente (wazero)
• Reprodução local do comportamento de produção WASM (CLI wasmtime)
• Microsserviços HTTP de edge com inícios frios rápidos (Spin)
• Pipelines de CI que executam lógica de convidado sem binários nativos
• Cargas de trabalho multi-inquilino que precisam de E/S com escopo de capacidade

Exemplo de Trabalho

Convidado (guest/main.go):

package main
 
import (
    "fmt"
    "os"
)
 
func main() {
    name, _ := os.Hostname()
    fmt.Println("hostname:", name)
    fmt.Println("env:", os.Getenv("GREETING"))
}

Compilar:

GOOS=wasip1 GOARCH=wasm go build -o guest.wasm ./guest

wasmtime:

wasmtime run --env GREETING=hello --dir .::/ guest.wasm

Host wazero (host/main.go):

package main
 
import (
    "context"
    "os"
 
    "github.com/tetratelabs/wazero"
    "github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1"
)
 
func main() {
    ctx := context.Background()
    r := wazero.NewRuntime(ctx)
    defer r.Close(ctx)
    wasi_snapshot_preview1.MustInstantiate(ctx, r)
 
    cfg := wazero.NewModuleConfig().
        WithEnv("GREETING", "hello from wazero").
        WithFSConfig(wazero.NewFSConfig().WithDirMount(".", "/"))
 
    wasm, _ := os.ReadFile("guest.wasm")
    mod, _ := r.InstantiateWithConfig(ctx, wasm, cfg)
    defer mod.Close(ctx)
 
    _, _ = mod.ExportedFunction("_start").Call(ctx)
}

Spin (spin.toml trecho + compilação):

spin_manifest_version = 2
 
[application]
name = "go-guest"
version = "0.1.0"
 
[[trigger.http]]
route = "/..."
component = "guest"
 
[component.guest]
source = "guest.wasm"
[component.guest.trigger]
route = "/"

spin build
spin up

O que isso demonstra:

• As flags do wasmtime se traduzem diretamente em concessões de capacidade.
• wazero expressa as mesmas concessões em APIs Go adequadas para servidores de longa execução.
• Spin conecta rotas HTTP a componentes WASM sem que você escreva um listener personalizado.

Mergulho Profundo

Como Funciona

• Todos os hosts compilam/carregam WASM, alocam memória linear e vinculam funções de importação WASI.
• _start (ou wrappers main exportados) é executado após a instanciação.
• O acesso ao sistema de arquivos nunca é implícito - os hosts mapeiam diretórios para o namespace do convidado.
• Variáveis de ambiente e argumentos são entradas curadas pelo host, espelhando pontos de entrada de contêineres.

Comparação de Runtimes

Padrões de Produção wazero

• Pool de runtimes por inquilino ou reutilize um runtime com módulos separados por solicitação - meça as compensações de memória.
• Prazos de contexto em Call limitam o tempo de CPU; combine com APIs de medição de combustível quando disponíveis.
• Feche módulos após o uso para liberar caches de código de máquina compilado em processos de longa execução.

Notas Go

// ABI de plugin estreita: o convidado lê JSON de stdin, escreve JSON de stdout.
// O host envolve Call com buffers via substituições de stdin/stdout do ModuleConfig.

Armadilhas

• Instanciação WASI ausente no wazero - Esquecer wasi_snapshot_preview1.MustInstantiate gera erros de importação obscuros. Correção: sempre registre WASI antes dos módulos convidados.

• Assumindo o diretório de trabalho - Convidados veem apenas caminhos pré-abertos, não o CWD do host. Correção: monte . explicitamente em / ou /work.

• Expectativas de rede Spin - Nem todo servidor Go net/http compila para um componente Spin sem adaptação. Correção: siga os padrões do SDK Go do Spin para manipuladores HTTP.

• Descompasso de versão do wasmtime - Hosts mais antigos não possuem snapshots WASI mais recentes. Correção: fixe o wasmtime em CI para corresponder à produção.

• Re-instanciar por solicitação sem cache - A compilação domina a latência fria. Correção: cacheie módulos compilados; reutilize wazero.CompiledModule.

• Passando caminhos de host sensíveis - --dir /::/ excessivamente amplo quebra o sandboxing. Correção: monte diretórios de menor privilégio por convidado.

Alternativas

FAQs

Relacionado

• Compilando com GOOS=wasip1 GOARCH=wasm - produza artefatos de convidado
• Go em WebAssembly: Caminhos de Navegador, WASI e Embutidos - WASI vs navegador
• Noções Básicas de WebAssembly & TinyGo - exemplo de incorporação wazero
• Otimização de Tamanho WASM: TinyGo vs gc WASM - orçamentos de tamanho de edge
• Melhores Práticas de WebAssembly & TinyGo - matriz de CI com wasmtime

Versões da Pilha: Esta página foi escrita para Go 1.26.x (padrão Green Tea GC, go fix modernizers - verifique o patch na compilação), chi (mais recente - verifique na compilação), gin (mais recente - verifique na compilação), echo (mais recente - verifique na compilação), google.golang.org/grpc (mais recente - verifique na compilação), sigs.k8s.io/controller-runtime (mais recente - verifique na compilação), kubebuilder (mais recente - verifique na compilação), tinygo (mais recente - verifique os alvos de placa na compilação), wazero (mais recente - verifique na compilação) e golangci-lint (mais recente - verifique o conjunto de linters na compilação).