Wie man in 30 Minuten eine REST API in Rust schreibt: Praktische Anleitung

Einleitung: Warum Rust für REST API?

Rust ist eine moderne Systemprogrammiersprache, die die Leistung von C/C++ mit Speichersicherheit ohne Garbage Collector kombiniert. Für die Erstellung von REST APIs bietet Rust mehrere leistungsstarke Frameworks, und Actix-web ist eines der beliebtesten. In dieser Anleitung erstellen wir Schritt für Schritt in 30 Minuten eine vollständige REST API in Rust. Sie werden sehen, wie schnell Sie loslegen können, selbst wenn Sie neu in Rust sind.

Umgebungsvorbereitung

Bevor Sie Code schreiben, stellen Sie sicher, dass Rust installiert ist. Falls nicht, führen Sie den Befehl aus:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Überprüfen Sie nach der Installation die Version:

rustc --version

Erstellen Sie nun ein neues Projekt:

cargo new rust_rest_api\ncd rust_rest_api

Öffnen Sie die Datei Cargo.toml und fügen Sie die Abhängigkeiten hinzu:

[dependencies]\nactix-web = "4"\nserde = { version = "1.0", features = ["derive"] }\nserde_json = "1.0"\ntokio = { version = "1", features = ["full"] }

Führen Sie cargo build aus, um alle Pakete zu installieren. Dies dauert 1–2 Minuten.

Erstellung einer grundlegenden REST API in Rust

Beginnen wir mit einem einfachen Endpunkt, der eine Begrüßung zurückgibt. Öffnen Sie src/main.rs und schreiben Sie:

use actix_web::{web, App, HttpServer, Responder};\n\nasync fn hello() -> impl Responder {\n    "Hallo Welt! Dies ist eine REST API in Rust!"\n}\n\n#[actix_web::main]\nasync fn main() -> std::io::Result<()> {\n    println!("Server gestartet unter http://127.0.0.1:8080");\n    HttpServer::new(|| {\n        App::new()\n            .route("/", web::get().to(hello))\n    })\n    .bind("127.0.0.1:8080")?\n    .run()\n    .await\n}

Starten Sie den Server mit dem Befehl cargo run und öffnen Sie http://127.0.0.1:8080 im Browser. Sie sehen unsere Begrüßung. Dies ist die Grundlage jeder REST API in Rust.

Hinzufügen von Datenstrukturen und JSON

Eine echte REST API arbeitet mit JSON. Erstellen wir ein Benutzermodell und einen Endpunkt, um es abzurufen:

use serde::{Deserialize, Serialize};\n\n#[derive(Serialize, Deserialize)]\nstruct User {\n    id: u32,\n    name: String,\n    email: String,\n}\n\nasync fn get_user() -> impl Responder {\n    let user = User {\n        id: 1,\n        name: "Ivan Petrov".to_string(),\n        email: "ivan@example.com".to_string(),\n    };\n    web::Json(user)\n}\n\n// Fügen Sie in main() eine neue Route hinzu:\n// .route("/user", web::get().to(get_user))

Unter der Adresse /user erhalten Sie nun ein JSON-Objekt. Dies ist ein entscheidender Punkt: Rust serialisiert die Struktur dank serde automatisch in JSON.

Arbeiten mit Abfrageparametern und POST-Anfragen

Eine echte API sollte verschiedene HTTP-Methoden und Parameter verarbeiten. Fügen wir einen Endpunkt zum Erstellen eines Benutzers per POST hinzu:

use actix_web::web::Json;\n\nasync fn create_user(user: Json<User>) -> impl Responder {\n    let new_user = user.into_inner();\n    println!("Benutzer erstellt: {} ({})", new_user.name, new_user.email);\n    web::Json(new_user)\n}\n\n// In main():\n// .route("/user", web::post().to(create_user))

Jetzt können Sie eine POST-Anfrage mit einem JSON-Body senden, z. B. mit curl:

curl -X POST http://127.0.0.1:8080/user \\\n  -H "Content-Type: application/json" \\\n  -d '{"id":2,"name":"Maria Smirnova","email":"maria@example.com"}'

Der Server gibt dasselbe Objekt zurück und bestätigt die Erstellung. Dies ist die Grundlage für CRUD-Operationen.

Verarbeitung von Pfadparametern und Query-Strings

Fügen wir einen Endpunkt hinzu, um einen Benutzer per ID über einen Pfadparameter abzurufen:

use actix_web::web::Path;\n\nasync fn get_user_by_id(path: Path<u32>) -> impl Responder {\n    let user_id = path.into_inner();\n    // In einer echten Anwendung würde hier eine Datenbankabfrage stehen\n