Runtimes Host WASI: wasmtime, wazero y Spin

Un binario wasip1/wasm es solo la mitad de la historia.

Algo debe instanciar el módulo, satisfacer las importaciones WASI y, opcionalmente, mapear disparadores HTTP o capacidades del sistema de archivos.

wasmtime, wazero y Spin son los tres hosts que los equipos de Go eligen primero: herramientas CLI, incrustación en procesos y HTTP en el edge, respectivamente.

Resumen

Compila Go con GOOS=wasip1 GOARCH=wasm, luego ejecuta el artefacto a través de un host que hable WASI Preview 1.

wasmtime sobresale en el desarrollo local y scripting.

wazero encaja en microservicios Go que cargan plugins en el proceso.

Spin empaqueta manejadores HTTP con opinión para despliegues en el edge al estilo Fermyon.

Cada host difiere en cómo otorga capacidades de sistema de archivos, entorno y red.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

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

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

Cuándo usar esto:

• Plugins en sandbox dentro de una API Go existente (wazero)
• Reproducción local del comportamiento WASM en producción (CLI wasmtime)
• Microservicios HTTP en el edge con arranques en frío rápidos (Spin)
• Pipelines de CI que ejecutan lógica de invitado sin binarios nativos
• Cargas de trabajo multi-inquilino que necesitan E/S con alcance de capacidades

Ejemplo de Trabajo

Invitado (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 extracto + build):

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

Lo que esto demuestra:

• Las banderas de wasmtime se traducen directamente en concesiones de capacidades.
• wazero expresa las mismas concesiones en APIs de Go adecuadas para servidores de larga ejecución.
• Spin conecta rutas HTTP a componentes WASM sin que usted escriba un listener personalizado.

Inmersión Profunda

Cómo Funciona

• Todos los hosts compilan/cargan WASM, asignan memoria lineal y vinculan las funciones de importación WASI.
• _start (o los wrappers main exportados) se ejecuta después de la instanciación.
• El acceso al sistema de archivos nunca es implícito: los hosts mapean directorios al espacio de nombres del invitado.
• Las variables de entorno y los argumentos son entradas curadas por el host, reflejando los puntos de entrada de los contenedores.

Comparación de Runtimes

Patrones de Producción de wazero

• Agrupa runtimes por inquilino o reutiliza un runtime con módulos separados por solicitud: mide las compensaciones de memoria.
• Plazos de contexto en Call limitan el tiempo de CPU; combínalo con APIs de medición de combustible cuando estén disponibles.
• Cierra módulos después de su uso para liberar cachés de código máquina compilado en procesos de larga ejecución.

Notas de Go

// ABI de plugin estrecha: el invitado lee JSON de stdin, escribe JSON de stdout.
// El host envuelve Call con buffers a través de las anulaciones de stdin/stdout de ModuleConfig.

Trampas

• Falta la instanciación WASI en wazero - Olvidar wasi_snapshot_preview1.MustInstantiate produce errores de importación oscuros. Solución: siempre registra WASI antes que los módulos invitados.

• Asumiendo el directorio de trabajo - Los invitados solo ven rutas pre-abiertas, no el CWD del host. Solución: monta . explícitamente en / o /work.

• Expectativas de red de Spin - No todos los servidores Go net/http compilan a un componente Spin sin adaptación. Solución: sigue los patrones del SDK de Spin para Go para los manejadores HTTP.

• Desajuste de versión de wasmtime - Los hosts más antiguos carecen de instantáneas WASI más nuevas. Solución: fija wasmtime en CI para que coincida con la producción.

• Re-instanciar por solicitud sin caché - La compilación domina la latencia en frío. Solución: almacena en caché los módulos compilados; reutiliza wazero.CompiledModule.

• Pasar rutas de host sensibles - --dir /::/ demasiado amplio rompe el sandboxing. Solución: monta directorios de mínimo privilegio por invitado.

Alternativas

Preguntas Frecuentes

Relacionado

• Compilación con GOOS=wasip1 GOARCH=wasm - produce artefactos de invitado
• Go en WebAssembly: Rutas de Navegador, WASI y Embebidas - WASI vs navegador
• Conceptos Básicos de WebAssembly y TinyGo - ejemplo de incrustación wazero
• Optimización de Tamaño WASM: TinyGo vs gc WASM - presupuestos de tamaño en el edge
• Mejores Prácticas de WebAssembly y TinyGo - matriz de CI con wasmtime

Versiones de Stack: Esta página fue escrita para Go 1.26.x (predeterminado Green Tea GC, modernizadores de go fix - verifica el parche en la compilación), chi (última - verifica en la compilación), gin (última - verifica en la compilación), echo (última - verifica en la compilación), google.golang.org/grpc (última - verifica en la compilación), sigs.k8s.io/controller-runtime (última - verifica en la compilación), kubebuilder (última - verifica en la compilación), tinygo (última - verifica los objetivos de placa en la compilación), wazero (última - verifica en la compilación), y golangci-lint (última - verifica el conjunto de linters en la compilación).