Fonctions Serverless en Rust : AWS Lambda – performances sans serveur

Fonctions Serverless en Rust : AWS Lambda – performance sans serveur

L'architecture Serverless est devenue la norme pour construire des applications évolutives et économiques. Cependant, les langages classiques pour AWS Lambda (Python, Node.js, Java) sont confrontés au problème du démarrage à froid et à une consommation mémoire élevée. Rust, avec son coût d'abstraction nul et sa compilation en code natif, propose une solution révolutionnaire : des fonctions qui se lancent en quelques millisecondes et consomment un minimum de ressources. Dans cet article, nous allons voir comment créer des fonctions Serverless en Rust pour AWS Lambda, configurer l'environnement et optimiser les performances.

Pourquoi Rust pour le Serverless ?

Le choix de Rust pour AWS Lambda repose sur trois facteurs clés :

• Démarrage à froid minimal : Le binaire Rust ne nécessite ni machine virtuelle ni interpréteur. Le temps de démarrage est de 50 à 200 ms contre 1 à 3 secondes pour Python ou Java.
• Faible consommation mémoire : Les fonctions Rust occupent 5 à 15 Mo de RAM, ce qui permet de réduire le coût d'exécution.
• Sécurité mémoire : Le système de possession (ownership) élimine les fuites mémoire et les conditions de concurrence, critiques pour les charges de production.

Rust est idéal pour les tâches sensibles à la latence : traitement de requêtes API, processus ETL, analyse en temps réel.

Configuration du projet et des outils

Pour le développement, vous aurez besoin de :

• Rust (installation via rustup)
• L'utilitaire cargo lambda (installation : cargo install cargo-lambda)
• Un compte AWS et AWS CLI configuré

Créez un nouveau projet :

cargo lambda new my-rust-functioncd my-rust-function

Le résultat sera une structure avec le fichier src/main.rs et Cargo.toml avec les dépendances nécessaires :

[package]name = "my-rust-function"version = "0.1.0"edition = "2021"

[dependencies]lambda_runtime = "0.11"serde = { version = "1.0", features = ["derive"] }serde_json = "1.0"tokio = { version = "1", features = ["macros"] }tracing = "0.1"tracing-subscriber = { version = "0.3", features = ["fmt"] }

La dépendance clé est lambda_runtime, qui fournit le runtime pour l'interaction avec AWS Lambda.

Écrire votre première fonction Serverless en Rust

Prenons un exemple simple : une fonction qui reçoit un JSON avec un nom et retourne un message de bienvenue.

Contenu de src/main.rs :

use lambda_runtime::{service_fn, LambdaEvent, Error};use serde::{Deserialize, Serialize};

#[derive(Deserialize)]struct Request {    name: String,}

#[derive(Serialize)]struct Response {    message: String,}

#[tracing::instrument(skip(event), fields(request_id = %event.context.request_id))]async fn handler(event: LambdaEvent<Request>) -> Result<Response, Error> {    let request = event.payload;    let message = format!("Bonjour, {} ! Tu as appelé une fonction Rust.", request.name);    Ok(Response { message })}

#[tokio::main]async fn main() -> Result<(), Error> {    tracing_subscriber::fmt()        .with_max_level(tracing::Level::INFO)        .init();

    let func = service_fn(handler);    lambda_runtime::run(func).await}

Analyse du code :

• LambdaEvent — une enveloppe contenant le payload et le contexte d'exécution.
• #[tracing::instrument] — journalisation automatique avec l'ID de la requête.
• service_fn — adapte un gestionnaire asynchrone pour le runtime Lambda.

Compilez et exécutez localement :

cargo lambda build --releasecargo lambda invoke --data-ascii '{"name": "Monde"}'

Sortie : {"message":"Bonjour, Monde ! Tu as appelé une fonction Rust."}