Skip to content
Learni
View all tutorials
Développement WebAssembly

Comment créer votre première app Spin Fermyon en 2026

12 minBEGINNER
ServerlessSpinFermyonWebAssemblyRust

Introduction

Spin, développé par Fermyon, est un framework open-source pour construire des microservices en WebAssembly (Wasm). Contrairement aux conteneurs traditionnels, Spin compile votre code en Wasm pour une exécution ultra-rapide, portable sur n'importe quel runtime (edge, cloud, on-prem). En 2026, avec l'essor de l'edge computing, Spin domine pour les APIs serverless : latence minimale, cold starts en millisecondes et isolation native.

Pourquoi l'adopter ? Imaginez des fonctions Lambda 10x plus rapides sans lock-in vendor. Ce tutoriel beginner vous guide pour créer une API HTTP simple en Rust : handler GET renvoyant JSON, build local, test et déploiement Fermyon Cloud. À la fin, vous aurez une app live, prête pour production. Durée : 20 min. Valeur : foundations solides pour scaler vers des apps complexes.

Prérequis

  • Système : macOS, Linux ou Windows (WSL recommandé)
  • Rust installé (via rustup.rs)
  • Git (pour versionning)
  • Compte gratuit Fermyon Cloud (optionnel pour déploiement)
  • Terminal basique

Installer la CLI Spin

terminal
curl -fsSL https://developer.fermyon.com/downloads/spin/spin-stable-linux-amd64.tar.gz | tar -C /usr/local --strip-components=1 -zxf -

# Sur macOS avec Homebrew
brew install spin

# Vérifier
spin --version

Cette commande télécharge et installe la CLI Spin stable (version 2026 compatible). Sur macOS, Homebrew simplifie. La vérification affiche la version (ex: v3.x), confirmant l'installation sans pièges comme les proxies bloquants – utilisez sudo si besoin root.

Créer votre premier projet Spin

Une fois la CLI installée, générez un squelette de projet. Spin supporte Rust, TinyGo, etc. ; on choisit Rust pour sa maturité et perfos natives. Le template http-rust crée un handler HTTP basique, prêt à customiser.

Générer le projet

terminal
spin new hello-spin --template http-rust
cd hello-spin

# Explorer la structure
git init  # Optionnel pour versionning
ls -la

La commande spin new scaffold un projet complet : Spin.toml pour config, src/lib.rs pour logic. --template http-rust cible APIs HTTP. Évitez les templates vides pour beginners ; ls montre Cargo.toml auto-généré, évitant setups manuels fastidieux.

Configurer Spin.toml

Spin.toml définit le composant : triggers (HTTP ici), bindings (volumes, Redis...), env vars. C'est le manifeste YAML-like pour déploiements. On le garde minimal pour démarrer.

Fichier de configuration Spin.toml

Spin.toml
spin_manifest_version = "2"

[application]
name = "hello-spin"
version = "1.0.0"

[[trigger.http]]
route = "/..."
component = "hello-spin"

[component]
source = { crate = "hello-spin" }
allowed_http_hosts = []

[component.build]
command = "cargo"

Ce manifest v2 (standard 2026) lie le trigger HTTP à toutes routes (/...). allowed_http_hosts sécurise les outbound calls. Piège : oubliez spin_manifest_version et le build échoue ; command = "cargo" automatise la compilation Wasm.

Implémenter le handler HTTP

Dans src/lib.rs, Spin utilise wit-bindgen pour interfaces Wasm standardisées (WIT). Le handler traite requests HTTP : parse JSON, retourne 200 OK. Analogie : comme Express.js mais compilé en Wasm pur.

Handler Rust principal

src/lib.rs
use spin_sdk::http::{IntoResponse, Request, Response};
use spin_sdk::http_component;

#[http_component]
fn handle_request(_req: Request) -> anyhow::Result<impl IntoResponse> {
    let body = r#"{"message": "Hello from Spin Fermyon 2026!"}"#;
    Ok(Response::builder()
        .status(200)
        .header("content-type", "application/json")
        .body(body)?)
}

Ce handler minimal répond JSON sur toute route POST/GET. http_component macro génère le WIT binding. Ajoutez anyhow pour errors gracieux. Piège : oubliez ? sur body() et paniquez en runtime ; testez avec curl post-build.

Build et tester localement

Compilez en Wasm optimisé, puis lancez le runtime Spin. Accédez via localhost:3000. Logs intégrés aident debug.

Build et run local

terminal
spin build

# Runner local
spin up

# Test en autre terminal
curl http://127.0.0.1:3000/ -

# Stopper : Ctrl+C

spin build cross-compile en hello-spin.sbg.wasm (format Spin Bundle Graph). spin up hot-reload dev mode. Curl teste l'endpoint ; attendez "Hello from Spin...". Piège : ports occupés – spin up --port 8080.

Déployer sur Fermyon Cloud

Pour prod, push vers Fermyon Cloud : gratuit, auto-scale. spin login authentifie, deploy publie.

Déploiement cloud

terminal
spin login  # Crée compte si besoin
spin deploy

# URL live affichée, ex: https://hello-spin.fermyon.app
curl https://<votre-app>.fermyon.app/

deploy build + upload atomique. Cloud gère scaling. Piège : sans login, erreur 401 ; vérifiez spin apps list post-deploy. URL publique = endpoint prod instantané.

Bonnes pratiques

  • Validez inputs : Utilisez serde pour JSON strict, évitez injections.
  • Gestion erreurs : Retournez toujours Response::builder().status(400) au lieu de panics.
  • Bindings dynamiques : Ajoutez Redis/KeyValue via [component.outbound_handler] pour stateful apps.
  • Optimisez Wasm : cargo build --release avant spin build pour tailles <1MB.
  • CI/CD : Intégrez GitHub Actions avec spin build && spin deploy.

Erreurs courantes à éviter

  • Oubli spin build : Runtime refuse sans .wasm généré.
  • Routes mal matchées : route = "/api/..." au lieu de "/..." bloque tests.
  • Dépendances manquantes : Ajoutez spin-sdk = "2" dans Cargo.toml ou build fail.
  • Cold starts ignorés : Testez avec spin up --timeout 30s pour simuler.

Pour aller plus loin

Comment créer app Spin Fermyon 2026 (Tutoriel) | Learni