Les 10 meilleurs frameworks Rust pour le développement web en 2024

Les 10 meilleurs frameworks Rust pour le développement web

Rust conquiert avec confiance le créneau du développement web grâce à ses performances, sa sécurité mémoire et son asynchronicité. Si vous recherchez un framework fiable pour créer des applications web en Rust, cet aperçu vous aidera à faire le bon choix. Nous examinerons les 10 meilleurs frameworks, leurs caractéristiques et des exemples de code.

1. Actix-web — le plus performant

Actix-web est le leader en termes de performances parmi les frameworks Rust. Il est basé sur le modèle Actor et Tokio. Idéal pour les API à forte charge.

use actix_web::{get, web, App, HttpServer, Responder};

#[get("/hello/{name}")]async fn greet(name: web::Path<String>) -> impl Responder {    format!("Hello {}!", name)}

#[actix_web::main]async fn main() -> std::io::Result<()> {    HttpServer::new(|| {        App::new().service(greet)    })    .bind(("127.0.0.1", 8080))?    .run()    .await}

2. Axum — moderne et écosystémique

Développé par l'équipe Tokio. Utilise les services tower et hyper. S'intègre parfaitement avec sqlx, tower, serde.

use axum::{Router, routing::get, response::Json};use serde_json::{json, Value};

async fn root() -> Json<Value> {    Json(json!({"message": "Hello from Axum"}))}

#[tokio::main]async fn main() {    let app = Router::new().route("/", get(root));    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();    axum::serve(listener, app).await.unwrap();}

3. Rocket — simplicité et confort

Conçu pour un démarrage rapide. Utilise des macros pour le routage. Idéal pour le prototypage.

#[macro_use] extern crate rocket;

#[get("/<name>")]fn hello(name: &str) -> String {    format!("Hello, {}!", name)}

#[launch]fn rocket() -> _ {    rocket::build().mount("/", routes![hello])}

4. Warp — fonctionnel et flexible

Basé sur des filtres (Filters). Permet de composer les gestionnaires comme des chaînes. Excellent choix pour les API.

use warp::Filter;

#[tokio::main]async fn main() {    let hello = warp::path!("hello" / String)        .map(|name| format!("Hello, {}!", name));

    warp::serve(hello)        .run(([127, 0, 0, 1], 3030))        .await;}

5. Tide — minimaliste et asynchrone

Framework léger des créateurs de Rust async. API simple basée sur les traits.

use tide::Request;

#[async_std::main]async fn main() -> tide::Result<()> {    let mut app = tide::new();    app.at("/").get(|_: Request<()>| async { Ok("Hello, Tide!") });    app.listen("127.0.0.1:8080").await?;    Ok(())}

6. Poem — pile complète avec OpenAPI

Prend en charge la génération automatique de spécifications OpenAPI. Intégration avec HTTP/2, WebSocket.

use poem::{get, handler, listener::TcpListener, Route, Server};

#[handler]fn hello() -> String {    "Hello, Poem!".to_string()}

#[tokio::main]async fn main() -> Result<(), std::io::Error> {    let app = Route::new().at("/", get(hello));    Server::new(TcpListener::bind("0.0.0.0:3000"))        .run(app)        .await}

7. Salvo — simple et puissant

Prend en charge middleware, WebSocket, formulaires multipart. Dispose d'un support intégré pour OpenAPI.

use salvo::prelude::*;

#[handler]async fn hello(res: &mut Response) {    res.render(Text::Plain("Hello, Salvo!"));}

#[tokio::main]async fn main() {    let router = Router::new().get(hello);    Server::new(TcpListener::bind("0.0.0.0:5800"))        .serve(router)        .await;}

8. Gotham — asynchrone et sécurisé

Utilise un typage strict et une sécurité au niveau de la compilation. Convient aux applications complexes.

use gotham::state::State;use gotham::r