Los 10 mejores frameworks de Rust para desarrollo web en 2024

Los 10 mejores frameworks de Rust para desarrollo web

Rust está ganando terreno en el desarrollo web gracias a su rendimiento, seguridad de memoria y asincronía. Si buscas un framework confiable para crear aplicaciones web en Rust, esta revisión te ayudará a tomar la decisión correcta. Analizaremos los 10 mejores frameworks, sus características y ejemplos de código.

1. Actix-web — el más eficiente

Actix-web es líder en rendimiento entre los frameworks de Rust. Está basado en el modelo Actor y Tokio. Es 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 y ecosistémico

Desarrollado por el equipo de Tokio. Utiliza servicios tower y hyper. Se integra excelentemente con 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 — simplicidad y comodidad

Orientado a un inicio rápido. Utiliza macros para el enrutamiento. Es ideal para prototipado.

#[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 y flexible

Basado en filtros (Filters). Permite componer manejadores como cadenas. Excelente elección 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 y asíncrono

Framework ligero de los creadores de Rust async. API simple basada en 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 — pila completa con OpenAPI

Soporta generación automática de especificaciones OpenAPI. Integración con 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 y potente

Soporta middleware, WebSocket, formularios multipart. Tiene soporte 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 — asíncrono y seguro

Utiliza tipado estricto y seguridad a nivel de compilación. Adecuado para aplicaciones complejas.

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