WASM-Prozesse

Ein process.wasm-Eintrag führt ein WASM-Modul unter einem Wippy Process Host aus und unterstützt Starten, Überwachen und kontrolliertes Herunterfahren.

Klassifizierung: Referenz zur Prozesskonfiguration und zum Lebenszyklus. Blöcke mit Binärdateien setzen einen externen Komponenten-Build sowie anwendungseigene Dateisystem-, Process-Host-, Umgebungs- und Policy-Einträge voraus. Platzhalter-Hashes müssen durch den exakten Digest der Binärdatei ersetzt werden.

Eintragskonfiguration

entries:
  - name: wasm_binaries
    kind: fs.directory
    directory: ./wasm

  - name: compute_worker
    kind: process.wasm
    fs: myns:wasm_binaries
    path: /worker.wasm
    hash: sha256:292b796376f8b4cc360acf2ea6b82d1084871c3607a079f30b446da8e5c984a4
    method: run
    imports:
      - wippy:actor
      - wasi:io
      - wasi:poll
    options:
      limits:
        memory_bytes: 67108864
      mailbox:
        capacity: 128
        bytes: 8388608
        message_bytes: 1048576

Konfigurationsfelder

Zustandsbehaftete WASM-Actors

Importieren Sie wippy:actor in einem Component-Gast, um auf die aktuelle PID und die begrenzte Mailbox zuzugreifen. Die Schnittstelle wippy:actor/process@0.1.0 stellt bereit:

Nachrichten enthalten die Sender-PID, ein Topic und bis zu 16 Payloads. Formate sind bytes, UTF-8-text und UTF-8-json. Das Senden wird als process.send gegen die Ziel-PID autorisiert. Fehlerhafte, zu große oder die Mailbox-Kapazität überschreitende Nachrichten werden abgelehnt, bevor der Gast sie erhält.

Der Gast exportiert normalerweise eine langlebige run-Funktion:

package example:worker;

world worker {
  import wippy:actor/process@0.1.0;
  import wasi:io/poll@0.2.8;
  export run: func() -> result<_, string>;
}

Rufen Sie in run in einer Schleife receive() auf, aktualisieren Sie den Gastzustand und antworten Sie mit send() an message.from. Die Rückkehr aus run beendet den Prozess.

Actor-Steuerung

Konfigurieren Sie dauerhafte Ressourcen- und Mailbox-Budgets unter options:

options:
  worker_class: wasm
  limits:
    memory_bytes: 67108864
    host_buffer_bytes: 8388608
    asyncify_stack_bytes: 65536
    max_execution_ms: 0
    max_open_sockets: 16
    socket_timeout_ms: 30000
  mailbox:
    capacity: 128
    bytes: 8388608
    message_bytes: 1048576

mailbox.message_bytes darf mailbox.bytes nicht überschreiten. Die Kapazität muss außerdem zum Mindestkonto von 256 Byte pro eingereihter Nachricht passen. Unbekannte Felder und ungültige Werte führen zur Ablehnung des Eintrags.

CLI-Befehle

Registrieren Sie einen WASM-Prozess mit meta.command als benannten Befehl:

  - name: greet
    kind: process.wasm
    meta:
      command:
        name: greet
        short: Greet someone via WASM
    fs: myns:wasm_binaries
    path: /component.wasm
    hash: sha256:...
    method: greet

Führen Sie ihn so aus:

wippy run greet

Listen Sie die verfügbaren Befehle auf:

wippy run list

Ein terminal.host muss vorhanden sein, damit CLI-Befehle funktionieren; er ist der Prozess-Host, der den Befehl ausfuehrt.

Prozesslebenszyklus

WASM-Prozesse folgen dem Lebenszyklus Init/Step/Close:

1. Init - Aufrufkontext, Methode und Eingabeargumente werden erfasst
2. Step - Der erste Schritt instanziiert und startet das Modul. Weitere Schritte führen über den Dispatcher vermittelte Operationen fort; eine synchrone Ausführung kann bereits im ersten Schritt abgeschlossen werden.
3. Close - Ressourcen der Instanz werden freigegeben

Aus Lua starten

Starten Sie einen WASM-Prozess und überwachen Sie ihn bis zum Abschluss:

local errors = require("errors")

-- Spawn with monitoring
local pid, err = process.spawn_monitored(
    "myns:compute_worker",   -- entry ID
    "myns:processes",        -- process host
    6, 7                     -- arguments passed to the WASM function
)

if err then
    return nil, err
end

-- Wait for the process to complete
local events = process.events()
while true do
    local event, open = events:receive()
    if not open then return nil, errors.new("process event channel closed") end
    if event.kind == process.event.EXIT and event.from == pid then
        local result = event.result.value  -- return value from the WASM function
        return result, event.result.error
    end
end

Asynchrone Ausführung

WASM-Actors können bei Host-Operationen yielden, die die Runtime über den Dispatcher vermittelt. Dazu gehören Mailbox-Empfang und -Versand, Polling, Uhren, Sockets, DNS, Dateisystem-Streams und ausgehendes HTTP. Der Scheduler pausiert den Prozess, bis die Operation abgeschlossen ist, und setzt danach dieselbe Gastinstanz fort:

  - name: http_worker
    kind: process.wasm
    fs: myns:wasm_binaries
    path: /http_worker.wasm
    hash: sha256:...
    method: run
    imports:
      - wasi:io
      - wasi:cli
      - wasi:http
    wasi:
      env:
        - id: myns:api_url
          name: API_URL
          required: true

Der Yield/Resume-Mechanismus ist für ein asyncifiziertes Core-Modul oder eine Komponente mit den unterstützten Pollable-Schnittstellen transparent.

WASI-Konfiguration

Prozesse unterstützen dieselbe WASI-Konfiguration wie Funktionen:

  - name: file_processor
    kind: process.wasm
    fs: myns:wasm_binaries
    path: /processor.wasm
    hash: sha256:...
    method: process
    imports:
      - wasi:cli
      - wasi:io
      - wasi:clocks
      - wasi:filesystem
    wasi:
      args: ["--input", "/data/input.csv"]
      cwd: "/app"
      env:
        - id: myns:output_format
          name: OUTPUT_FORMAT
      mounts:
        - fs: myns:input_data
          guest: /data
          read_only: true
        - fs: myns:output_dir
          guest: /output

Siehe auch

• Übersicht - Übersicht über die WebAssembly-Runtime
• Funktionen - Konfiguration von WASM-Funktionen
• Host-Funktionen - Verfügbare Host-Schnittstellen
• Prozessmodell - Prozesslebenszyklus
• Supervision - Prozess-Supervision-Trees