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

Einleitung: Warum Rust für REST-APIs?

Rust ist eine moderne systemnahe Programmiersprache, die die Leistung von C++ mit Speichersicherheit kombiniert. In den letzten Jahren wird sie aktiv für die Erstellung hochbelastbarer Webdienste und REST-APIs eingesetzt. In dieser Anleitung erstellen wir in 30 Minuten eine vollständige REST-API mit Rust unter Verwendung des Frameworks Actix-web.

Warum sollte man Rust für REST-APIs wählen?

• Leistung: Rust wird in nativen Code kompiliert und verwendet keinen Garbage Collector, was maximale Geschwindigkeit bei der Anfrageverarbeitung bietet.
• Sicherheit: Das Ownership- und Borrowing-System schließt ganze Klassen von Speicherfehlern aus.
• Skalierbarkeit: Actix-web ist eines der schnellsten Web-Frameworks der Welt und kann Millionen von Anfragen pro Sekunde verarbeiten.

Am Ende des Artikels haben Sie ein fertiges Projekt mit mehreren Endpunkten, Fehlerbehandlung und einer Struktur für zukünftige Erweiterungen.

Schritt 1: Projekteinrichtung und Installation der Abhängigkeiten

Als erstes erstellen wir ein neues Cargo-Projekt. Öffnen Sie ein Terminal und führen Sie Folgendes aus:

cargo new rust_rest_apicd rust_rest_api

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

[dependencies]actix-web = "4"serde = { version = "1.0", features = ["derive"] }serde_json = "1.0"tokio = { version = "1", features = ["full"] }uuid = { version = "1.0", features = ["v4", "serde"] }

Lassen Sie uns erklären, wofür jede Bibliothek zuständig ist:

• actix-web — das Haupt-Webframework zur Erstellung des HTTP-Servers.
• serde / serde_json — Serialisierung und Deserialisierung von Daten in das JSON-Format.
• tokio — die asynchrone Laufzeitumgebung, die für den Betrieb von Actix erforderlich ist.
• uuid — Generierung eindeutiger Identifikatoren für unsere Entitäten.

Führen Sie cargo build aus, um alle Abhängigkeiten herunterzuladen. Dies wird beim ersten Start einige Zeit in Anspruch nehmen.

Schritt 2: Erstellung des Datenmodells und des Speichers

Unsere API wird eine Aufgabenliste (TODO-Anwendung) verwalten. Erstellen wir ein einfaches Modell. Öffnen Sie src/main.rs und fügen Sie den folgenden Code hinzu:

use actix_web::{web, App, HttpServer, HttpResponse, middleware::Logger};use serde::{Deserialize, Serialize};use std::sync::Mutex;use uuid::Uuid;

// Aufgabenmodell#[derive(Debug, Serialize, Deserialize, Clone)]struct Task {    id: Uuid,    title: String,    completed: bool,}

// Anfrage zur Aufgabenerstellung#[derive(Debug, Deserialize)]struct CreateTaskRequest {    title: String,}

// Aufgabenspeicher (im Arbeitsspeicher)struct AppState {    tasks: Mutex>,}

Wir verwenden Mutex für den threadsicheren Zugriff auf die Daten. In einem realen Projekt würden Sie dies durch eine Datenbank ersetzen, aber für die Demonstration ist diese Variante ausreichend.

Fügen wir nun eine Funktion zur Initialisierung des Anwendungszustands hinzu:

fn init_tasks() -> Vec {    vec![        Task {            id: Uuid::new_v4(),            title: "Rust lernen".to_string(),            completed: false,        },        Task {            id: Uuid::new_v4(),            title: "REST-API schreiben".to_string(),            completed: true,        },    ]}

Schritt 3: Implementierung der CRUD-Endpunkte

Jetzt erstellen wir die grundlegenden Handler für unsere REST-API. Fügen Sie den folgenden Code nach der Deklaration der Modelle hinzu:

GET /tasks — Abrufen der Liste aller Aufgaben

async fn get_tasks(data: web::Data<AppState>) -> HttpResponse {    let tasks = data.tasks.lock().unwrap();    HttpResponse::Ok().json(tasks.clone())}

POST /tasks — Erstellen einer neuen Aufgabe

async fn create_task(    data: web::Dat