10 лучших фреймворков Rust для веб-разработки: продвинутый уровень

Введение: Rust в веб-разработке — от системного кода к высоконагруженным API

Rust прочно занял нишу высокопроизводительных backend-систем, где критичны скорость, безопасность памяти и предсказуемость. Для веб-разработчика, уже знакомого с основами языка, выбор фреймворка — это баланс между экосистемой, асинхронностью и архитектурными паттернами. В этой статье мы разберем 10 зрелых фреймворков, которые подходят для продакшн-проектов, микросервисов и real-time приложений.

1. Actix-web: ветеран асинхронности

Actix-web остаётся одним из самых быстрых HTTP-фреймворков в мире (по данным TechEmpower). Основан на actor-модели и tokio. Идеален для REST API и WebSocket-серверов.

Пример: простой REST endpoint

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

async fn hello() -> impl Responder {
    "Привет из Actix-web!"
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| App::new().route("/", web::get().to(hello)))
        .bind(("127.0.0.1", 8080))?
        .run()
        .await
}

Когда выбирать: когда нужна максимальная производительность (более 1 млн RPS), сложные WebSocket-соединения или интеграция с actor-моделью.

2. Axum: современный стандарт от команды Tokio

Axum — часть экосистемы tokio/tower. Использует концепцию "middleware as tower services" и встроенную поддержку async fn обработчиков. Считается самым эргономичным для типичных REST-сервисов.

Пример: извлечение JSON

use axum::{Json, Router, routing::post};
use serde::Deserialize;

#[derive(Deserialize)]
struct User { name: String }

async fn create_user(Json(user): Json<User>) -> String {
    format!("Создан пользователь: {}", user.name)
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/user", post(create_user));
    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap();
}

Когда выбирать: для микросервисов с tower-промежуточным слоем, интеграция с OpenTelemetry, или если вы уже используете tokio.

3. Rocket: макросы и ergonomics

Rocket делает упор на декларативность через атрибуты. Имеет встроенную валидацию форм, сериализацию и ORM-интеграцию (через Diesel). Версия 0.5+ полностью async.

Пример: маршрут с параметром

#[macro_use] extern crate rocket;

#[get("/hello/<name>")]
fn hello(name: &str) -> String {
    format!("Привет, {}!", name)
}

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

Когда выбирать: для быстрого прототипирования, проектов с активным использованием форм/файлов, или если вы цените минимализм кода.

4. Warp: функциональный композитор

Warp построен на filter-системе, где каждый middleware — это фильтр, комбинируемый через .and() и .or(). Очень гибок, но требует понимания типов Rust.

Пример: комбинирование фильтров

use warp::Filter;

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

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

Когда выбирать: для сложной маршрутизации, WebSocket-прокси или когда нужно тонко контролировать pipeline обработки.

5. Tide: лёгкость и минимализм

Tide от команды Rust Async Working Group. Минимальные зависимости, простая middleware-цепочка. Хорош для небольших сервисов и обучения асинхронности.

Пример: middleware логирования

use tide::{Request, Response, Middleware, Next};

struct Logger;
#[tide::utils::async_trait]
impl<State: Clone + Send + Sync + 'static> Middleware<State> for Logger {
    async fn handle(&self, req: Request<State>, next: Next<State>) -> Result {
        println!("Запрос: {}", req.url());
        Ok(next.run(req).await)
    }
}

#[async_std::main]
async fn main() -> tide::Result<()> {
    let mut app = tide::new();
    app.with(Logger);
    app.at("/").get(|_| async { Ok("Tide работает") });
    app.listen("127.0.0.1:8080").await?;
    Ok(())
}

Когда выбирать: для простых API, учебных проектов или когда не нужны тяжелые зависимости.

6. Poem: полный контроль над HTTP

Poem — фреймворк с поддержкой OpenAPI, WebSocket, SSE и gRPC. Имеет собственный middleware-слой, похожий на tower. Поддерживает HTTP/2 и TLS из коробки.

Пример: endpoint с OpenAPI

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

#[handler]
fn index() -> String {
    "Poem API".to_string()
}

#[tokio::main]
async fn main() {
    let app = Route::new().at("/", get(index));
    Server::new(TcpListener::bind("0.0.0.0:3000"))
        .run(app)
        .await
        .unwrap();
}

Когда выбирать: для проектов с обязательной OpenAPI-документацией, gRPC-прокси или HTTP/2.

7. Salvo: китайский "убийца" с богатой экосистемой

Salvo (ранее Rbatis) — быстрый фреймворк с встроенной поддержкой JWT, CORS, сессий и шаблонизаторов. Имеет собственный ORM (Rbatis) и активно развивается.

Пример: защита маршрута JWT

use salvo::prelude::*;

#[handler]
async fn hello() -> &'static str {
    "Доступ разрешён"
}

#[tokio::main]
async fn main() {
    let router = Router::new()
        .hoop(auth::j