Rust + Actix-web: Costruire API Veloci che Davvero Scalano

Siamo onesti: quando ci serve una REST API veloce, la maggior parte di noi apre Node.js o Python. Conosciamo già il compromesso: velocità di sviluppo contro performance, prototipazione rapida contro affidabilità in produzione.

Ma se ti dicessi che puoi avere entrambe le cose?

È la promessa di Rust, e Actix-web è il framework che la rende realtà per noi sviluppatori web.

Perché Rust per le API? (La Verità che Non Vogliono Dirti)

Prima di scrivere una sola riga di codice, parliamo dell'elefante nella stanza: Rust ha una curva di apprendimento ripida. Non è gentile. Il borrow checker ti metterà in ginocchio. Passerai ore a debuggare i lifetimes invece di rilasciare funzionalità.

Ma ecco cosa mi ha fatto cambiare idea: Rust non ti costringe a scegliere tra sicurezza e velocità. La tua API sarà memory-safe di default. Niente null pointer exceptions, niente data races, niente pause del garbage collector che massacrano le tue latenze p99. Quando servizi migliaia di richieste al secondo, quella costanza fa la differenza.

Per startup e sviluppatori che scalano sistemi, significa performance prevedibili senza il peso operativo di gestire un layer di sicurezza separato.

Primi Passi con Actix-web

Actix-web prende ispirazione dal framework Elixir/Phoenix (senza essere affiliato). Abbraccia il modello ad attori e offre un'API ergonomica che risulta familiare se hai già usato Express, Fastify o simili.

Configurare il Progetto

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

Il Tuo Primo 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
}

Quell'endpoint health? Compila in millisecondi e parte in microsecondi. Lancia cargo run e hitta localhost:8080/health—vedrai la risposta JSON immediatamente.

Costruire un'API Vera: Todos con Operazioni CRUD

Costruiamo qualcosa di più pratico. Un'API Todo con le classiche operazioni CRUD.

Definire il Modello Dati

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

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

Implementare i Gestori

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

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

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

Collegare Tutto nel Main

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let data = web::Data::new(AppState {
        todos: Mutex::new(Vec::new()),
        next_id: Cell::new(1),
    });

    HttpServer::new(move || {
        App::new()
            .app_data(data.clone())
            .route("/todos", web::get().to(get_todos))
            .route("/todos", web::post().to(create_todo))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

Il Vantaggio Reale

Ecco cosa ottieni alla fine: un'API che compila una volta e gira ovunque senza dipendenze runtime. Zero garbage collection, zero memory leaks, prestazioni costanti sotto carico.

Non è per tutti. Il prezzo da pagare è l'apprendimento iniziale. Ma se stai costruendo qualcosa che deve scalare, durare, servire milioni di richieste senza sorprese—Rust e Actix-web sono una combinazione che difficilmente troverai altrove.

Il tuo prossimo progetto? Potrebbe essere quello giusto per provare.