10 лучших фреймворков Rust для веб-разработки в 2024

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

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

Rust уверенно завоевывает нишу веб-разработки благодаря своей производительности, безопасности памяти и асинхронности. Если вы ищете надежный фреймворк для создания веб-приложений на Rust, этот обзор поможет вам сделать правильный выбор. Мы рассмотрим 10 лучших фреймворков, их особенности и примеры кода.

1. Actix-web — самый производительный

Actix-web — лидер по производительности среди Rust-фреймворков. Основан на Actor-модели и Tokio. Идеален для высоконагруженных API.

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 — современный и экосистемный

Разработан командой Tokio. Использует tower-сервисы и гипер. Отлично интегрируется с 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 — простота и удобство

Ориентирован на быстрый старт. Использует макросы для маршрутизации. Идеален для прототипирования.

#[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 — функциональный и гибкий

Основан на фильтрах (Filters). Позволяет компоновать обработчики как цепочки. Отличный выбор для API.

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 — минималистичный и асинхронный

Легковесный фреймворк от создателей Rust async. Простой API, основанный на трейтах.

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 — полный стек с OpenAPI

Поддерживает автоматическую генерацию OpenAPI-спецификации. Интеграция с 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 — простой и мощный

Поддерживает middleware, WebSocket, multipart-формы. Имеет встроенную поддержку 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 — асинхронный и безопасный

Использует строгую типизацию и безопасность на уровне компиляции. Подходит для сложных приложений.

use gotham::state::State;
use gotham::router::Router;
use gotham::pipeline::new_pipeline;
use gotham::handler::HandlerFuture;

fn say_hello(state: State) -> (State, String) {
    (state, "Hello, Gotham!".to_string())
}

fn main() {
    let router = Router::new().get("/").to(say_hello);
    gotham::start("127.0.0.1:8080", router);
}

9. Nickel — минималистичный

Вдохновлен Express.js. Простой синтаксис, подходит для быстрых прототипов.

#[macro_use] extern crate nickel;
use nickel::Nickel;

fn main() {
    let mut app = Nickel::new();
    app.get("/", middleware!("Hello, Nickel!"));
    app.listen("127.0.0.1:6767");
}

10. Thruster — легковесный и быстрый

Основан на Hyper. Поддерживает middleware и WebSocket. Минимальные накладные расходы.

use thruster::{App, BasicContext as Ctx, Request};
use thruster::{middleware::basic, middleware::query};
use thruster::server::Server;

async fn hello(mut context: Ctx, _next: impl FnOnce(Ctx) -> Ctx) -> Ctx {
    context.body("Hello, Thruster!");
    context
}

fn main() {
    let app = App::<Request, Ctx>::new_basic(hello);
    Server::new(app).start("0.0.0.0", 8080);
}