Rust ha madurado significativamente como un lenguaje backend de primer nivel. Este artículo evalúa los principales frameworks web de Rust, centrándose en las diferencias entre los líderes actuales de la industria: Axum y Actix-web. Cubrimos sus patrones arquitectónicos, perfiles de rendimiento y proporcionamos un fragmento de código de inicio para ayudarte a elegir el framework adecuado.

1. Descripción general de los principales frameworks

Al construir aplicaciones web o microservicios en Rust, los desarrolladores generalmente eligen entre estos dos frameworks:

1) Axum

Axum es desarrollado y mantenido por el equipo de tokio, los creadores del runtime asíncrono de facto de Rust.

• Integración perfecta con Tokio: Se basa directamente en hyper (implementación HTTP), tower (primitivas de middleware) y tracing (diagnóstico), evitando desajustes de runtime.
• Enrutamiento sin macros: A diferencia de muchas alternativas, Axum evita macros de atributo personalizadas. Aprovecha el sistema de tipos nativo de Rust para extractores de solicitudes, haciendo que los errores del compilador sean más fáciles de diagnosticar.
• A prueba de futuro: Axum es actualmente la opción más popular para nuevos proyectos backend en Rust, respaldada por una comunidad grande y creciente.

2) Actix-web

Actix-web es uno de los frameworks web más antiguos y probados del ecosistema Rust.

• Rendimiento máximo: Se clasifica consistentemente cerca de la cima de los benchmarks de TechEmpower, mostrando un rendimiento increíble y una latencia mínima.
• Legado basado en actores: Diseñado sobre primitivas de actores, aísla contextos de ejecución del runtime, garantizando una seguridad de hilos y eficiencia de recursos excepcionales.
• Ecosistema maduro: Su larga trayectoria significa abundantes plugins, adaptadores de bases de datos y recursos comunitarios disponibles en línea.

2. Implementación de una API web con Axum

Aquí hay un ejemplo de inicio que ilustra cómo definir rutas, extraer solicitudes JSON y devolver payloads estructurados usando Axum y serde:

use axum::{
    routing::{get, post},
    Json, Router,
};
use serde::{Deserialize, Serialize};
use std::net::SocketAddr;

#[derive(Serialize)]
struct User {
    id: u64,
    username: String,
}

#[derive(Deserialize)]
struct CreateUser {
    username: String,
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/user", get(get_user))
        .route("/user", post(create_user));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println("escuchando en {}", addr);

    let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

async fn get_user() -> Json<User> {
    Json(User {
        id: 1,
        username: "user_name_example".to_string(),
    })
}

async fn create_user(Json(payload): Json<CreateUser>) -> Json<User> {
    Json(User {
        id: 2,
        username: payload.username,
    })
}

Este fragmento muestra serialización/deserialización con seguridad de tipos, asegurando que las entradas inválidas sean rechazadas automáticamente antes de llegar a la lógica de negocio central.

3. ¿Qué framework deberías elegir?

Aquí hay un resumen de las diferencias:

Recomendación

• Elige Axum si te diriges a contenedores nativos de nube, entornos serverless, o quieres una base de código moderna que se integre perfectamente con las bibliotecas estándar de Tokio.
• Elige Actix-web si estás desplegando en servidores bare-metal o instancias de cómputo dedicadas donde minimizar latencias de submilisegundos y exprimir el máximo rendimiento es tu objetivo principal.