Розробка бекенду сайту на Rust (Actix Web)

Ваш сайт працює під навантаженням 10 000 RPS, але latency скаче від 5 до 200 мс, а на графіках моніторингу — горби GC-пауз. Node.js або Python задихаються. Час переходити на Rust та Actix Web — фреймворк, який на TechEmpower benchmarks стабільно в першій п'ятірці, випереджаючи Node.js та Go. Ми маємо понад 7 років досвіду в Rust та більше 20 проєктів на Actix Web. Розробляємо надшвидкий бекенд: компіляція в машинний код, акторна модель, безпека пам'яті на рівні компілятора. Розповімо, як це знижує latency до 1 мс та економить ресурси.

Як Actix Web досягає продуктивності?

Фреймворк побудований на акторній моделі та неблокуючому I/O на базі tokio. Кожен обробник — це актор, який обробляє запити паралельно без блокувань. Rust стискає бінарник до 5–15 МБ, відсутня збірка сміття — передбачуваний час відгуку. Порівняйте з Node.js: під навантаженням Actix Web споживає в 2 рази менше пам'яті (5–15 МБ проти 30–80 МБ) і дає в 10 разів менше latency (p99 < 1 мс).

Чому Rust безпечніший для бекенду?

Система типів Rust виключає цілі класи вразливостей: null-покажчики, переповнення буфера та гонки даних. Весь код перевіряється на етапі компіляції. sqlx — бібліотека для PostgreSQL — перевіряє коректність SQL-запитів під час компіляції. Якщо запит не відповідає схемі БД — ви отримаєте помилку збірки, не runtime. У наших проєктах це скорочує кількість багів у production на 40%.

Що дає використання Actix Web для вашого бізнесу?

В одному проєкті ми замінили Node.js API на Actix Web: latency впала з 50 мс до 1 мс, споживання пам'яті знизилося в 5 разів. Це означає менше серверів, нижчі витрати на інфраструктуру та швидший відгук для користувачів. Компанії економлять до 70% на хостингу при збереженні продуктивності.

Структура типового застосунку

// main.rs
use actix_web::{middleware, web, App, HttpServer};
use sqlx::PgPool;

mod config;
mod db;
mod errors;
mod handlers;
mod models;
mod services;

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    dotenvy::dotenv().ok();
    tracing_subscriber::fmt()
        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
        .init();

    let cfg = config::Config::from_env().expect("invalid config");
    let pool = PgPool::connect(&cfg.database_url).await.expect("db connect failed");
    sqlx::migrate!("./migrations").run(&pool).await.expect("migration failed");

    let pool = web::Data::new(pool);

    HttpServer::new(move || {
        App::new()
            .app_data(pool.clone())
            .app_data(web::JsonConfig::default().error_handler(errors::json_error_handler))
            .wrap(middleware::Logger::default())
            .wrap(middleware::Compress::default())
            .service(
                web::scope("/api/v1")
                    .service(handlers::users::scope())
                    .service(handlers::orders::scope()),
            )
    })
    .bind(("0.0.0.0", cfg.port))?
    .workers(num_cpus::get())
    .run()
    .await
}

Моделі та безпечні запити до БД

// models/user.rs
use serde::{Deserialize, Serialize};
use sqlx::FromRow;
use time::OffsetDateTime;
use uuid::Uuid;

#[derive(Debug, Serialize, FromRow)]
pub struct User {
    pub id: Uuid,
    pub email: String,
    pub display_name: String,
    #[serde(skip)]
    pub password_hash: String,
    pub created_at: OffsetDateTime,
}

#[derive(Debug, Deserialize)]
pub struct CreateUserPayload {
    pub email: String,
    pub display_name: String,
    pub password: String,
}

// db/users.rs
pub async fn find_by_id(pool: &PgPool, id: Uuid) -> sqlx::Result<Option<User>> {
    sqlx::query_as!(
        User,
        r#"
        SELECT id, email, display_name, password_hash, created_at
        FROM users
        WHERE id = $1
        "#,
        id
    )
    .fetch_optional(pool)
    .await
}

pub async fn create(pool: &PgPool, payload: &CreateUserPayload) -> sqlx::Result<User> {
    let hash = bcrypt::hash(&payload.password, bcrypt::DEFAULT_COST).unwrap();
    sqlx::query_as!(
        User,
        r#"
        INSERT INTO users (id, email, display_name, password_hash)
        VALUES ($1, $2, $3, $4)
        RETURNING *
        "#,
        Uuid::new_v4(),
        payload.email,
        payload.display_name,
        hash
    )
    .fetch_one(pool)
    .await
}

Обробники та роутинг

// handlers/users.rs
use actix_web::{get, post, web, HttpResponse, Scope};
use sqlx::PgPool;
use uuid::Uuid;
use crate::{db, errors::AppError, models::user::CreateUserPayload};

pub fn scope() -> Scope {
    web::scope("/users")
        .service(get_user)
        .service(create_user)
}

#[get("/{id}")]
async fn get_user(
    pool: web::Data<PgPool>,
    id: web::Path<Uuid>,
) -> Result<HttpResponse, AppError> {
    let user = db::users::find_by_id(&pool, *id)
        .await?
        .ok_or(AppError::NotFound("user not found".into()))?;
    Ok(HttpResponse::Ok().json(user))
}

#[post("")]
async fn create_user(
    pool: web::Data<PgPool>,
    payload: web::Json<CreateUserPayload>,
) -> Result<HttpResponse, AppError> {
    let user = db::users::create(&pool, &payload).await?;
    Ok(HttpResponse::Created().json(user))
}

Обробка помилок

// errors.rs
use actix_web::{HttpResponse, ResponseError};
use serde_json::json;

#[derive(Debug, thiserror::Error)]
pub enum AppError {
    #[error("not found: {0}")]
    NotFound(String),
    #[error("validation error: {0}")]
    Validation(String),
    #[error("database error")]
    Database(#[from] sqlx::Error),
    #[error("unauthorized")]
    Unauthorized,
}

impl ResponseError for AppError {
    fn error_response(&self) -> HttpResponse {
        match self {
            AppError::NotFound(msg) => HttpResponse::NotFound().json(json!({ "error": msg })),
            AppError::Validation(msg) => HttpResponse::UnprocessableEntity().json(json!({ "error": msg })),
            AppError::Unauthorized => HttpResponse::Unauthorized().json(json!({ "error": "unauthorized" })),
            AppError::Database(e) => {
                tracing::error!("db error: {:?}", e);
                HttpResponse::InternalServerError().json(json!({ "error": "internal error" }))
            }
        }
    }
}

Аутентифікація через JWT

Додаємо middleware, що перевіряє JWT-токен у заголовку Authorization. Middleware реалізований як актор, перехоплює запит до обробника. При невалідному токені — 401. Фреймворк надає зручні трейти, і ми часто пакуємо JWT-валідацію в окремий сервіс для перевикористання.

Порівняння Actix Web з альтернативами

Деплой та інфраструктура

Підсумковий бінарник — самодостатній файл без зовнішніх залежностей. Docker-образ можна зібрати на scratch: достатньо скопіювати бінарник. Це спрощує деплой у Kubernetes та CI/CD. Один інстанс Actix замінює 5–10 Node.js-сервісів під навантаженням, що відчутно економить на серверних потужностях. Отримайте консультацію інженера — ми оцінимо ваш проєкт і покажемо, скільки ви заощадите на інфраструктурі.

Процес роботи

1. Аналітика — уточнення вимог, профілювання навантаження, вибір інфраструктури.
2. Проєктування — архітектура, схема БД, API-контракти.
3. Реалізація — написання коду з код-рев'ю та тестуванням.
4. Навантажувальне тестування — перевірка заявлених RPS та latency.
5. Деплой — розгортання на обраному хостингу, моніторинг.

Терміни: простий CRUD API (5–8 ресурсів) — від 2 до 3 тижнів, високонавантажений сервіс — від 4 до 7 тижнів. Вартість розраховується індивідуально. Замовте прототип за 2 тижні — ми покажемо результат.

Що входить у роботу

• Документація API (OpenAPI/Swagger)
• Повна тестова база (unit + інтеграційні)
• Міграції БД та seed-дані
• CI/CD-пайплайн (GitHub Actions)
• Навчання вашої команди роботі з кодом
• Гарантія продуктивності (SLA по latency та throughput)

Зв'яжіться з нами для аудиту вашого проєкту — ми запропонуємо оптимальне рішення на Rust.