`Dezvoltarea Microserviciilor REST de Ultra-Înaltă Performanță cu Axum și Tower în Rust` în Rust

Bazele limbajului Rust Standard Rust

Ghid complet de producție pentru crearea API-urilor REST cu Axum și Tower în Rust: rutare tipizată, injectarea stării globale cu State, middleware-uri distribuite pentru telemetrie și tratarea sigură a erorilor HTTP.

Sintaxă

Router::new().route('/api', get(handler)).layer(TraceLayer::new_for_http())

Pentru dezvoltarea serviciilor de backend, Axum este framework-ul web modern dezvoltat și întreținut direct de echipa oficială Tokio. Construit pe fundația robustă a bibliotecilor hyper (HTTP de nivel scăzut) și tower (abstracțiuni universale de middleware), Axum oferă o viteză de procesare apropiată de limita teoretică a rețelei, cu o sintaxă elegantă și verificare 100% la compilare.

Inovația majoră din Axum este conceptul de Extractoare (Extractors): parametrii funcțiilor handler descriu declarativ ce anume trebuie extras din cererea HTTP (JSON, parametri de query, variabile de cale, starea aplicației), eșecul validării fiind tratat automat de framework.

Implementarea unui Microserviciu REST Complet cu Axum și Tower

use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::IntoResponse,
    routing::{get, post},
    Json, Router,
};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use tokio::net::TcpListener;
use tower_http::trace::TraceLayer;

// 1. Modelul de date:
#[derive(Serialize, Deserialize, Clone)]
struct Produs {
    id: u64,
    titlu: String,
    pret: f64,
}

// 2. Starea partajată a microserviciului (Thread-Safe):
struct AppState {
    baza_de_date_url: String,
}

// 3. Handlere tipizate curate:
async fn handler_creare_produs(
    State(state): State>,
    Json(payload): Json,
) -> impl IntoResponse {
    println!("Produs salvat în DB [{}]: {}", state.baza_de_date_url, payload.titlu);
    (StatusCode::CREATED, Json(payload))
}

async fn handler_detalii_produs(
    Path(id): Path,
) -> impl IntoResponse {
    let mock = Produs {
        id,
        titlu: format!("Produs {}", id),
        pret: 99.99,
    };
    (StatusCode::OK, Json(mock))
}

#[tokio::main]
async fn main() -> Result<(), Box> {
    let stare_partajata = Arc::new(AppState {
        baza_de_date_url: String::from("postgresql://dexblog@localhost/prod"),
    });

    // 4. Construirea arborelui de rutare și atașarea middleware-urilor Tower:
    let app = Router::new()
        .route("/produse", post(handler_creare_produs))
        .route("/produse/:id", get(handler_detalii_produs))
        .layer(TraceLayer::new_for_http()) // Logging distribuit automat pentru fiecare cerere HTTP
        .with_state(stare_partajata);

    // 5. Pornirea serverului asincron:
    let listener = TcpListener::bind("0.0.0.0:8080").await?;
    println!("Microserviciul Axum rulează pe http://0.0.0.0:8080");
    axum::serve(listener, app).await?;
    Ok(())
}

De Ce Axum Este Superior Altor Framework-uri (Actix-web / Rocket)?

Ecosistem Unificat: Compatibilitate 100% nativă cu întregul ecosistem Tokio și middleware-urile tower-http (rate limiting, compresie, CORS, OpenTelemetry tracing).
Sistem de Tipuri Declarativ: Nu există macro-uri de adnotare opace pe funcții; semnătura funcției determină complet modul de parsare și serializare a datelor.