Serverless mit Rust: Schneller als AWS Lambda mit Kaltstart

Serverless mit Rust: Wenn jede Millisekunde zählt

Haben Sie schon einmal 3-4 Sekunden auf den Start einer AWS Lambda gewartet? Wenn Sie mit Python oder Node.js in einer Serverless-Umgebung gearbeitet haben, kennen Sie diesen Schmerz – den Kaltstart. Stellen Sie sich nun vor: Ihre Funktion startet in 50-100 Millisekunden, verbraucht 10-mal weniger Speicher und die Binärdatei wiegt nur 5 Megabyte. Willkommen in der Welt der Serverless-Funktionen in Rust.

Rust ist nicht ohne Grund in die Serverless-Welt eingebrochen. Es ist eine Sprache, die Kontrolle über den Speicher ohne Garbage Collector bietet, in nativen Code kompiliert wird und sich ideal für Edge-Computing eignet. Auf PythonLib lieben wir Python, aber wenn es um Geschwindigkeit und Kosten geht – besonders bei hohen Lasten – wird Rust zum Killer.

In diesem Artikel behandeln wir:

\n
• Warum Rust die beste Sprache für Serverless ist (Spoiler: nicht nur wegen der Geschwindigkeit)
\n
• Wie man eine AWS Lambda in Rust schreibt und bereitstellt
\n
• Alternativen: Cloudflare Workers und Vercel Edge Functions
\n
• Kaltstart-Benchmarks Rust vs. Python
\n

Bereit? Los geht's.

Warum Rust für Serverless kein Hype, sondern Mathematik ist

Kommen wir direkt zu den Zahlen. Der durchschnittliche Kaltstart einer AWS Lambda in Python beträgt 400-800 ms (mit Laden der Abhängigkeiten). In Node.js sind es 200-400 ms. In Rust sind es 30-100 ms. Warum dieser Unterschied?

\n
• Kein Interpreter oder JIT. Rust wird in Maschinencode kompiliert. Lambda lädt einfach die Binärdatei – und fertig.
\n
• Minimale Größe. Selbst mit tokio und serde wiegt die Binärdatei 5-15 MB (komprimiertes Zip: 2-4 MB). Python mit numpy oder pandas wiegt 50-200 MB.
\n
• Speichereinsparung. Rust-Funktionen verbrauchen 20-50 MB im Vergleich zu 128-256 MB für Python. Bei 10 Millionen Anfragen beträgt der Kostenunterschied Hunderte von Dollar.
\n

Es gibt jedoch einen Haken: Das Schreiben in Rust ist schwieriger. Man muss Ownership, Lifetimes und Async verstehen. Wenn Ihre Lambda jedoch ein kritischer Mikroservice mit RPS > 1000 ist, amortisiert sich Rust schnell.

Praxis: Eine AWS Lambda in Rust schreiben

Schritt 1: Installation der Tools

Sie benötigen:

\n
• Rust (rustup)
\n
• cargo-lambda – ein Tool zum Bauen für AWS
\n
• Docker (zum Bauen unter Linux, wenn Sie macOS/Windows verwenden)
\n

# cargo-lambda installieren\ncargo install cargo-lambda\n\n# Neues Projekt erstellen\ncargo lambda new my-rust-lambda\ncd my-rust-lambda

Schritt 2: Funktionscode

Öffnen Sie src/main.rs. Die Standardvorlage enthält bereits eine grundlegende Struktur. Lassen Sie uns etwas Nützliches schreiben – eine API, die JSON mit einem Namen akzeptiert und eine Begrüßung zurückgibt.

use lambda_runtime::{run, service_fn, Error, LambdaEvent};\nuse serde::{Deserialize, Serialize};\n\n#[derive(Deserialize)]\nstruct Request {\n    name: String,\n}\n\n#[derive(Serialize)]\nstruct Response {\n    message: String,\n    timestamp: u64,\n}\n\nasync fn handler(event: LambdaEvent<Request>) -> Result<Response, Error> {\n    let request = event.payload;\n    let timestamp = std::time::SystemTime::now()\n        .duration_since(std::time::UNIX_EPOCH)\n        .unwrap()\n        .as_secs();\n\n    Ok(Response {\n        message: format!("Hallo, {}! Du bist auf PythonLib, aber wir sind auf Rust 🦀", request.name),\n        timestamp,\n    })\n}\n\n#[tokio::main]\nasync fn main() -> Result<(), Error> {\n    tracing_subscriber::fmt()\n        .with_max_level(tracing::Level::INFO)\n        .init();\n\n    run(service_fn(handler)).await\n}

Schritt 3: Bauen und Bereitstellen

# Für Linux bauen (für Lambda)\ncargo lambda build --release\n\n# Bereitstellen (AWS Credentials erforderlich)\ncargo lambda deploy --iam-role arn:aws:iam::YOUR_ACCOUNT:role/lambda-execution-role

Fertig! Sie haben jetzt eine Lambda in Rust, die 5-10 mal schneller arbeitet als das Python-Pendant.