Rust + Actix-web: Tez va Haqiqatan Ishlaydigan API Lar Yaratish

To'g'risi—ko'pchilik tez REST API kerak bo'lsa, Node.js yoki Python ga qo'l sozadi. Tradeoff larni bilamiz: developer tezligi versus ishlash tezligi. Lekin agar ikkalasini birda alıshingiz mumkin bo'lsa-chi?

Rust aynan shuni va'da qiladi. Actix-web esa uni web developerlar uchun qulay qiladigan framework.

Nega aynan Rust? (Noqulay Haqiqat)

Kod yozishdan oldin, asosiy savol: Rust o'rganish qiyinmi? Ha, oson emas. Borrow checker sizni jiddiy sinab ko'radi. Lifetimelar bilan ovora bo'lib, feature lar yetkazish o'rniga xatolarni tuzatishga vaqt sarflaysiz.

Lekin bir narsa muhim: Rust sizdan xavfsizlik va tezlikdan birini tanlashni talab qilmaydi. API ngiz default da memory-safe bo'ladi. Null pointer yo'q, data race yo'q, garbage collection tufayli p99 latency tushishi yo'q. Minglab requestlarni serving qilayotganda, bu barqarorlik katta ahamiyatga ega.

Startup lar va sistemalarni scale qilayotgan developerlar uchun bu—qo'shimcha xavfsizlik qatlamini boshqarish kerak emas, lekin performance bashorat qilinadigan bo'ladi.

Actix-web bilan Boshlash

Actix-web Elixir/Phoenix dan ilhom olgan, lekin unga tegishli emas. Actor model ni qo'llab, Express yoki Fastify dan foydalangan bo'lsangiz, API tushinarli bo'ladi.

Loyihani Sozlash

cargo new rust-api-demo
cd rust-api-demo
cargo add actix-web actix-rt

Birinchi Endpoint

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

async fn health_check() -> HttpResponse {
    HttpResponse::Ok().json(serde_json::json!({
        "status": "healthy",
        "version": env!("CARGO_PKG_VERSION")
    }))
}

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

Shu health endpoint? Millisekundlarda compile bo'ladi, mikrosekundlarda ishga tushadi. cargo run ni ishga tushiring, localhost:8080/health ga o'ting—JSON javobingiz tayyor.

Haqiqiy API: Todo va CRUD Amallar

Endi esa amaliyroq narsa quralay—to'liq CRUD amallari bilan Todo API.

Ma'lumotlar Modeli

use serde::{Deserialize, Serialize};
use std::sync::Mutex;
use std::cell::Cell;

#[derive(Clone, Serialize, Deserialize)]
struct Todo {
    id: u64,
    title: String,
    completed: bool,
}

Keling, qolgan qismini ham davom ettiramiz:

In-Memory State va Handler lar

struct AppState {
    todos: Mutex<Vec<Todo>>,
    counter: Cell<u64>,
}

async fn get_todos(data: web::Data<AppState>) -> HttpResponse {
    let todos = data.todos.lock().unwrap();
    HttpResponse::Ok().json(&*todos)
}

async fn create_todo(
    data: web::Data<AppState>,
    body: web::Json<Todo>,
) -> HttpResponse {
    let mut todos = data.todos.lock().unwrap();
    let id = data.counter.get() + 1;
    data.counter.set(id);
    
    let new_todo = Todo {
        id,
        title: body.title.clone(),
        completed: body.completed,
    };
    
    todos.push(new_todo);
    HttpResponse::Created().json(todos.last().unwrap())
}

Asosiy Funksiya

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let app_data = web::Data::new(AppState {
        todos: Mutex::new(Vec::new()),
        counter: Cell::new(0),
    });
    
    HttpServer::new(move || {
        App::new()
            .app_data(app_data.clone())
            .route("/todos", web::get().to(get_todos))
            .route("/todos", web::post().to(create_todo))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

Qanday Ishlaydi?

GET /todos — barcha todo larni oladi

POST /todos — yangi todo qo'shadi

Shunchaki, toza va tushunarli. Middleware, routing, error handling— hammasi familiar his qiladi, lekin Rust ning ishlash tezligi bilan birga.

Xulosa

Actix-web — bu Node.js dagi Express kabi oson, lekin C++ darajasida tez. Learning curve bor, rost. Lekin bir marta o'rganib olsangiz, production da ishonchli API lar yaratishda yangi darajaga o'tasiz.

Performance muhim bo'lsa, Rust albatta sinab ko'rishga arzigulik.