Die 10 besten Rust-Frameworks für die Webentwicklung im Jahr 2024

Die 10 besten Rust-Frameworks für die Webentwicklung

Rust erobert sich aufgrund seiner Leistung, Speichersicherheit und Asynchronität souverän eine Nische in der Webentwicklung. Wenn Sie nach einem zuverlässigen Framework für die Erstellung von Webanwendungen in Rust suchen, hilft Ihnen dieser Überblick bei der richtigen Wahl. Wir betrachten die 10 besten Frameworks, ihre Besonderheiten und Codebeispiele.

1. Actix-web — das leistungsstärkste

Actix-web ist der Leistungsführer unter den Rust-Frameworks. Es basiert auf dem Actor-Modell und Tokio. Ideal für hochbelastete APIs.

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 — modern und ökösystemorientiert

Entwickelt vom Tokio-Team. Nutzt tower-Services und Hyper. Lässt sich hervorragend mit sqlx, tower, serde integrieren.

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 — Einfachheit und Benutzerfreundlichkeit

Ausgerichtet auf einen schnellen Start. Verwendet Makros für das Routing. Ideal für das Prototyping.

#[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 — funktional und flexibel

Basiert auf Filtern. Ermöglicht die Verkettung von Handlern. Eine ausgezeichnete Wahl für APIs.

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 — minimalistisch und asynchron

Leichtgewichtiges Framework von den Erstellern von Rust async. Einfache API, basierend auf 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 — Vollstack mit OpenAPI

Unterstützt die automatische Generierung von OpenAPI-Spezifikationen. Integration mit 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 — einfach und leistungsstark

Unterstützt Middleware, WebSocket, Multipart-Formulare. Hat integrierte OpenAPI-Unterstützung.

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 — asynchron und sicher

Nutzt strenge Typisierung und Sicherheit auf Kompilierungsebene. Geeignet für komplexe Anwendungen.

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