Serverless en Rust : Plus rapide qu'AWS Lambda avec un démarrage à froid

Serverless en Rust : Quand chaque milliseconde compte

Avez-vous déjà attendu le démarrage d'une AWS Lambda pendant 3 à 4 secondes entières ? Si vous avez travaillé avec Python ou Node.js dans un environnement serverless, vous connaissez cette douleur — le démarrage à froid. Imaginez maintenant : votre fonction démarre en 50 à 100 millisecondes, consomme 10 fois moins de mémoire, et le binaire ne pèse que 5 mégaoctets. Bienvenue dans le monde des fonctions serverless en Rust.

Rust a fait irruption dans le serverless pour une bonne raison. C'est un langage qui offre un contrôle de la mémoire sans ramasse-miettes, se compile en code natif et est parfait pour les calculs en périphérie (edge computing). Sur PythonLib, nous adorons Python, mais quand il s'agit de vitesse et de coût — surtout sous forte charge — Rust devient un tueur.

Dans cet article, nous allons aborder :

\n
• Pourquoi Rust est le meilleur langage pour le serverless (spoiler : pas seulement à cause de la vitesse)
\n
• Comment écrire et déployer une AWS Lambda en Rust
\n
• Les alternatives : Cloudflare Workers et Vercel Edge Functions
\n
• Les benchmarks de démarrage à froid Rust vs Python
\n

Prêt ? C'est parti.

Pourquoi Rust pour le Serverless n'est pas un effet de mode, mais des mathématiques

Allons droit aux chiffres. Le démarrage à froid moyen d'une AWS Lambda en Python est de 400 à 800 ms (avec le chargement des dépendances). En Node.js — 200 à 400 ms. En Rust — 30 à 100 ms. Pourquoi une telle différence ?

\n
• Pas d'interpréteur ni de JIT. Rust se compile en code machine. Lambda charge simplement le binaire — et c'est prêt.
\n
• Taille minimale. Même avec tokio et serde, le binaire pèse 5 à 15 Mo (zip compressé — 2 à 4 Mo). Python avec numpy ou pandas — 50 à 200 Mo.
\n
• Économie de mémoire. Les fonctions Rust consomment 20 à 50 Mo contre 128 à 256 Mo pour Python. Sur 10 millions de requêtes, la différence sur la facture se chiffre en centaines de dollars.
\n

Mais il y a un hic : écrire en Rust est plus difficile. Il faut comprendre la possession (ownership), les durées de vie (lifetimes), l'asynchrone. Cependant, si votre Lambda est un microservice critique avec un RPS > 1000, Rust s'avère rapidement rentable.

Pratique : Écrivons une AWS Lambda en Rust

Étape 1 : Installation des outils

Vous aurez besoin de :

\n
• Rust (rustup)
\n
• cargo-lambda — un utilitaire pour la compilation vers AWS
\n
• Docker (pour la compilation sous Linux, si vous êtes sur macOS/Windows)
\n

# Installation de cargo-lambda\ncargo install cargo-lambda\n\n# Création d'un nouveau projet\ncargo lambda new my-rust-lambda\ncd my-rust-lambda

Étape 2 : Code de la fonction

Ouvrez src/main.rs. Le modèle standard contient déjà une structure de base. Écrivons quelque chose d'utile — une API qui reçoit un JSON avec un nom et renvoie un message de bienvenue.

use lambda_runtime::{run, service_fn, Error, LambdaEvent};\nuse serde::{Deserialize, Serialize};\n\n#[derive(Deserialize)]\nstruct Request {\n    name: String,\n}\n\n#[derive(Serialize)]\nstruct Response {\n    message: String,\n    timestamp: u64,\n}\n\nasync fn handler(event: LambdaEvent<Request>) -> Result<Response, Error> {\n    let request = event.payload;\n    let timestamp = std::time::SystemTime::now()\n        .duration_since(std::time::UNIX_EPOCH)\n        .unwrap()\n        .as_secs();\n\n    Ok(Response {\n        message: format!("Bonjour, {} ! Tu es sur PythonLib, mais nous sommes sur Rust 🦀", request.name),\n        timestamp,\n    })\n}\n\n#[tokio::main]\nasync fn main() -> Result<(), Error> {\n    tracing_subscriber::fmt()\n        .with_max_level(tracing::Level::INFO)\n        .init();\n\n    run(service_fn(handler)).await\n}

Étape 3 : Compilation et déploiement

# Compilation sous Linux (pour Lambda)\ncargo lambda build --release\n\n# Déploiement (nécessite des identifiants AWS)\ncargo lambda deploy --iam-role arn:aws:iam::YOUR_ACCOUNT:role/lambda-execution-role

Terminé ! Vous avez maintenant une Lambda en Rust qui fonctionne 5 à 10 fois plus vite que son équivalent Python.