Rust + Actix-web: Olyan API-k, amik tényleg skálázódnak

Be kell, hogy valljak valamit — amikor gyorsan kell egy REST API, a legtöbben automatikusan a Node.js vagy a Python felé nyúlunk. Tudjuk, mire számítsunk: fejlesztői sebesség kontra teljesítmény, prototípus kontra production-ready megbízhatóság.

De mi van, ha nem kellene kompromisszumot kötnünk?

Ez a Rust ígérete, az Actix-web pedig az a keretrendszer, ami ezt webes fejlesztőknek is elérhetővé teszi.

Miért éri meg a Rust API-khoz? (A kellemetlen igazság)

Mielőtt bármilyen kódsort írnál, beszéljünk őszintén a dologról: a Rustnak van tanulási görbéje. És ez finoman szólva sem egy enyhe emelkedő. A borrow checker előbb-utóbb megtanít alázatosnak lenni. Órákat fogsz tölteni azzal, hogy lifetimes-okat debugolj ahelyett, hogy funkciókat szállítanál.

De ami nekem végül összeállt: a Rust nem kényszerít arra, hogy válassz a biztonság és a sebesség között. Az API-d alapból memory-safe lesz — nincs null pointer exception, nincs data race, nincs garbage collection pause, ami ott akadályozza a p99 latency-t. Ha másodpercenként több ezer kérést szolgálsz ki, ez a kiszámíthatóság aranyat ér.

Startupoknak és skálázó fejlesztőknek ez azt jelenti, hogy kiszámítható teljesítményt kapsz anélkül, hogy külön biztonsági réteget kellene menedzselned.

Actix-web: Első lépések

Az Actix-web-et az Elixir/Phoenix inspirálta (bár nem kapcsolódik hozzájuk hivatalosan). Az actor modellt használja, és egy ergonomikus API-t kínál, ami ismerős lesz, ha dolgoztál már Express-szel, Fastify-jal vagy hasonló keretrendszerekkel.

Projekt beállítása

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

Az első 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
}

Ez a health endpoint? Milliszekundumok alatt fordul és mikroszekundumok alatt indul. Futtasd a cargo run-t, és nyisd meg a localhost:8080/health-et — azonnal látod a JSON választ.

Éles API építése: Todo app CRUD műveletekkel

Most építsünk valami gyakorlatiasabbat — egy Todo API-t teljes CRUD támogatással.

Az adatmodell definiálása

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

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

Az alkalmazás logika

A teljes Todo API-ban létrehozod a listát, frissíted a státuszt, törölöd a bejegyzéseket — mindezt pár sor Rust kóddal. Az eredmény? Olyan API, ami resource-okat hatékonyan kezel, és a teljesítménye nem fog cserben hagyni, amikor a terhelés megnő.