🔴 Advanced

WebAssembly Containers — Wasm ako budúcnosť kontajnerov

WebAssembly (Wasm) bol pôvodne navrhnutý pre web prehliadače, no dnes sa stáva serióznou alternatívou pre serverové workloady. Solomon Hykes, spoluzakladateľ Dockeru, povedal: "Keby Wasm existoval v 2008, nepotrebovali by sme Docker." Čo to znamená pre budúcnosť kontajnerizácie?

Čo je WebAssembly?

WebAssembly je binárny inštrukčný formát — kompaktný, rýchly, bezpečný bytecode, do ktorého sa dá kompilovať z mnohých jazykov (Rust, Go, C/C++, Python, JavaScript).

Kľúčové vlastnosti Wasm

  • Sandboxed — beží v izolovanom prostredí, nemá prístup k systému
  • Portable — rovnaký bytecode beží na ľubovoľnej platforme
  • Near-native speed — AOT/JIT kompilovaný, blízko natívnemu výkonu
  • Malá veľkosť — typický Wasm modul má 1-10 MB (vs 100+ MB Docker image)
  • Instant startup — štart v mikrosekundách (vs sekundy pre kontajnery)

Wasm vs Docker kontajnery

Aspekt Docker kontajner Wasm modul
Veľkosť 50-500 MB 1-10 MB
Štart 1-10 sekúnd < 1 ms
Izolácia Kernel namespaces Bytecode sandbox
Portabilita Linux/arch specific Univerzálna
Overhead OS + runtime Minimálny
Bezpečnosť Root escape riziko Capability-based
Ekosystém Zrelý, obrovský Rastúci

WASI — WebAssembly System Interface

WASI je štandardné API, ktoré umožňuje Wasm modulom interagovať so systémom (súbory, sieť, hodiny) bezpečným spôsobom.

Capability-based security

Wasm modul nemá žiadny prístup k systému by default. Prístup sa udeľuje explicitne:

# Wasm modul má prístup len k /data priečinku, read-only
wasmtime run --dir /data::/data:readonly app.wasm

# Prístup k sieti + konkrétnemu priečinku
wasmtime run \
  --dir /app/config::/config \
  --tcplisten 0.0.0.0:8080 \
  server.wasm

WasmEdge

WasmEdge je CNCF Sandbox projekt — ľahký, vysoko výkonný Wasm runtime optimalizovaný pre cloud a edge.

Príklad: HTTP server v Ruste pre WasmEdge

use hyper::service::{make_service_fn, service_fn};
use hyper::{Body, Request, Response, Server};

async fn handle(_req: Request<Body>) -> Result<Response<Body>, hyper::Error> {
    Ok(Response::new(Body::from("Hello from WasmEdge!")))
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
    let addr = ([0, 0, 0, 0], 8080).into();
    let service = make_service_fn(|_| async {
        Ok::<_, hyper::Error>(service_fn(handle))
    });
    Server::bind(&addr).serve(service).await.unwrap();
}

# Kompilácia do Wasm
cargo build --target wasm32-wasip1 --release

# Spustenie
wasmedge target/wasm32-wasip1/release/server.wasm

WasmEdge s Kubernetes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: wasm-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: wasm-app
  template:
    metadata:
      labels:
        app: wasm-app
      annotations:
        module.wasm.image/variant: compat-smart
    spec:
      runtimeClassName: wasmedge
      containers:
        - name: app
          image: registry.example.com/wasm-app:latest
          ports:
            - containerPort: 8080

Spin — Framework pre Wasm mikroslužby

Spin je open-source framework od Fermyon pre budovanie serverless Wasm aplikácií. Ponúka jednoduchý developer experience.

Vytvorenie Spin aplikácie

# Inštalácia Spin
curl -fsSL https://developer.fermyon.com/downloads/install.sh | bash

# Nový projekt
spin new -t http-rust my-api
cd my-api

Spin komponent v Ruste

use spin_sdk::http::{IntoResponse, Request, Response};
use spin_sdk::http_component;

#[http_component]
fn handle_request(req: Request) -> anyhow::Result<impl IntoResponse> {
    let path = req.uri().path();

    match path {
        "/api/health" => Ok(Response::builder()
            .status(200)
            .body("OK")?),
        "/api/hello" => Ok(Response::builder()
            .status(200)
            .header("content-type", "application/json")
            .body(r#"{"message": "Ahoj zo Spin!"}"#)?),
        _ => Ok(Response::builder()
            .status(404)
            .body("Not Found")?),
    }
}

spin.toml konfigurácia

spin_manifest_version = 2

[application]
name = "my-api"
version = "0.1.0"

[[trigger.http]]
route = "/api/..."
component = "my-api"

[component.my-api]
source = "target/wasm32-wasip1/release/my_api.wasm"
allowed_outbound_hosts = ["https://api.example.com"]

[component.my-api.build]
command = "cargo build --target wasm32-wasip1 --release"

# Build a spustenie
spin build
spin up

# Deploy na Fermyon Cloud
spin deploy

Docker + Wasm

Docker Desktop a Docker Engine podporujú Wasm workloady natívne od verzie 4.15+.

Wasm image v Docker

FROM scratch
COPY target/wasm32-wasip1/release/app.wasm /app.wasm
ENTRYPOINT ["/app.wasm"]

# Build Wasm image
docker buildx build --platform wasi/wasm -t my-wasm-app .

# Spustenie
docker run --runtime=io.containerd.wasmedge.v1 \
  --platform=wasi/wasm \
  -p 8080:8080 \
  my-wasm-app

Docker Compose s Wasm

services:
  web:
    image: my-wasm-app
    runtime: io.containerd.wasmedge.v1
    platform: wasi/wasm
    ports:
      - "8080:8080"

  api:
    image: my-traditional-api
    ports:
      - "3000:3000"

Wasm a tradičné kontajnery môžu bežať vedľa seba v tom istom Docker Compose stacku.

Fermyon Cloud

Fermyon ponúka managed platformu pre Spin aplikácie — serverless Wasm v cloude:

  • Instant cold start — žiadne cold start problémy ako u Lambda
  • Pay per request — platíte len za spracované requesty
  • Global edge — distribúcia po celom svete
  • Key-value store — built-in perzistentné úložisko

Kedy použiť Wasm namiesto kontajnerov?

Ideálne use cases pre Wasm

  • Serverless/FaaS — ultra-rýchly štart
  • Edge computing — malé binárky, nízky overhead
  • Plugin systémy — bezpečné spúšťanie nedôveryhodného kódu
  • CLI nástroje — cross-platform distribúcia
  • IoT — obmedzené zdroje

Kde zostať pri kontajneroch

  • Komplexné aplikácie — full-stack apps s mnohými závislosťami
  • Existujúce workloady — nie všetko sa dá ľahko portovať
  • Databázy — I/O intenzívne workloady
  • Zrelý ekosystém — keď potrebujete široký tooling

Stav ekosystému (2026)

Projekt Stav Popis
WASI Preview 2 Stabilný Networking, HTTP, key-value
Spin v3.x Production-ready framework
WasmEdge CNCF Sandbox Kubernetes-native runtime
Fermyon Cloud GA Managed Wasm platform
Docker Wasm GA Native Wasm support v Docker
wasmCloud CNCF Sandbox Distributed Wasm platform
Component Model Stabilný Composable Wasm components

Best Practices

  1. Začnite s novými služami — neportujte existujúce monolity
  2. Používajte Spin alebo wasmCloud — high-level frameworky šetria čas
  3. Rust je ideálny jazyk — najlepší Wasm support
  4. Testujte lokálne — spin up pre rýchly dev loop
  5. Kombinujte s kontajnermi — Wasm pre edge/serverless, kontajnery pre zvyšok

WebAssembly neprichádza nahradiť Docker kontajnery, ale doplniť ich. Pre serverless, edge a vysokovýkonné workloady ponúka Wasm zásadné výhody — rýchlejší štart, menšie binárky a silnejšiu izoláciu.