Rust + Actix-web: ultraschnelle APIs, die wirklich skalieren

Mal ganz ehrlich – die meisten von uns greifen bei einer schnellen REST-API zu Node.js oder Python. Wir kennen die Abwägung: Entwicklungsgeschwindigkeit gegen Performance, schnelles Prototyping gegen Produktionsreife. Aber was, wenn man beides haben könnte?

Genau das verspricht Rust, und Actix-web macht es für Webentwickler zugänglich.

Warum Rust für APIs? (Die unbequeme Wahrheit)

Bevor wir eine einzige Zeile Code schreiben, sollten wir das Thema direkt angehen: Rust hat eine Lernkurve. Und die ist alles andere als sanft. Der Borrow Checker wird dich demütigen. Du wirst Stunden damit verbringen, Lifetimes zu debuggen, statt Features auszuliefern.

Aber was mir klargeworden ist: Rust zwingt dich nicht, dich zwischen Sicherheit und Geschwindigkeit zu entscheiden. Deine API ist standardmäßig memory-safe – keine Null-Pointer-Exceptions, keine Data Races, keine Garbage-Collection-Pausen, die deine P99-Latenzen in den Keller drücken. Wenn du Tausende Requests pro Sekunde bedienst, dann zählt diese Beständigkeit.

Für Startups und Entwickler, die Systeme skalieren, bedeutet das vorhersehbare Performance ohne den operativen Aufwand, eine separate Sicherheitsschicht zu verwalten.

Actix-web kennenlernen

Actix-web ist inspiriert von (aber nicht verbunden mit) dem Elixir/Phoenix-Framework. Es setzt auf das Actor-Modell und bietet eine ergonomische API, die sich vertraut anfühlt, wenn du schon mit Express, Fastify oder ähnlichen Frameworks gearbeitet hast.

Projekt einrichten

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

Dein erster 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
}

Dieser Health-Endpoint? Er kompiliert in Millisekunden und startet in Mikrosekunden. Führe cargo run aus und rufe localhost:8080/health auf – du siehst sofort deine JSON-Antwort.

Eine echte API bauen: Todos mit CRUD-Operationen

Lass uns etwas Praktischeres bauen – eine Todo-API mit vollständigen CRUD-Operationen.

Datenmodell definieren

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

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

Der Clou hier: Mit Rust bekommst du Typsicherheit, ohne dass eine Runtime dahintersteckt. Die Kompilierzeit ist dein Verbündeter, nicht dein Feind.