10 melhores frameworks Rust para desenvolvimento web em 2024

10 melhores frameworks Rust para desenvolvimento web

Rust está conquistando com confiança o nicho de desenvolvimento web graças ao seu desempenho, segurança de memória e assincronicidade. Se você está procurando um framework confiável para criar aplicações web em Rust, esta visão geral ajudará você a fazer a escolha certa. Vamos analisar os 10 melhores frameworks, suas características e exemplos de código.

1. Actix-web — o mais performático

Actix-web é o líder em desempenho entre os frameworks Rust. Baseado no modelo Actor e Tokio. Ideal para APIs de alta carga.

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 — moderno e ecossistêmico

Desenvolvido pela equipe Tokio. Utiliza serviços tower e hyper. Integra-se perfeitamente com 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 — simplicidade e conveniência

Focado em início rápido. Utiliza macros para roteamento. Ideal para prototipagem.

#[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 — funcional e flexível

Baseado em filtros (Filters). Permite compor handlers como cadeias. Excelente escolha para 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 — minimalista e assíncrono

Framework leve dos criadores do Rust async. API simples baseada em 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 — pilha completa com OpenAPI

Suporta geração automática de especificação OpenAPI. Integração com 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 — simples e poderoso

Suporta middleware, WebSocket, formulários multipart. Possui suporte integrado para 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 — assíncrono e seguro

Utiliza tipagem estrita e segurança em nível de compilação. Adequado para aplicações complexas.

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