Skip to content
Learni
Voir tous les tutoriels
Développement WebAssembly

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

12 minBEGINNER
ServerlessSpinFermyonWebAssemblyRust
Read in English

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