Learn Rust Coding · Lektion

REST-APIs mit Actix-web/Rocket

Entwickeln Sie RESTful APIs mit einem modernen Rust-Webframework wie Actix-web oder Rocket und verarbeiten Sie Routen, Anfragen und Antworten.

REST-APIs mit Actix-web/Rocket ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.

Was sind REST-APIs?

REST, kurz für REpresentational State Transfer, ist ein Architekturstil für vernetzte Anwendungen. Er definiert eine Reihe von Prinzipien dafür, wie Webdienste miteinander kommunizieren sollen.

Betrachten Sie REST als eine Sammlung von Richtlinien zum Erstellen von Webdiensten, die zustandslos und cachebar sind und standardisierte HTTP-Methoden zur Interaktion mit Ressourcen verwenden.

Ressourcen: Alles, was benannt werden kann, etwa ein Benutzer, ein Produkt oder eine Bestellung.
URIs: Eindeutige Bezeichner für Ressourcen (z. B. /users/123).
HTTP-Methoden: Standardaktionen, die auf Ressourcen ausgeführt werden (GET, POST, PUT, DELETE).

Warum Rust für Webdienste?

Rust bietet bei der Entwicklung von Webdiensten einzigartige Vorteile und ist daher eine gute Wahl für performante und zuverlässige APIs:

Performance: Die Abstraktionen ohne Laufzeitkosten von Rust ermöglichen äußerst effizienten Code, der oft mit C/C++ vergleichbar ist.
Speichersicherheit: Das Ownership-System verhindert häufige Fehler wie die Dereferenzierung von Nullzeigern und Data Races, wodurch robustere Dienste entstehen.
Parallelität: Das async/await-Modell von Rust ermöglicht zusammen mit seinen Sicherheitsgarantien den Aufbau nebenläufiger Webdienste ohne Angst vor typischen Fehlern.
Zuverlässigkeit: Das starke Typsystem und Prüfungen zur Compile-Zeit erkennen viele Fehler frühzeitig.

Actix-web kennenlernen

Für die Entwicklung von Webdiensten in Rust verwenden wir häufig Frameworks. Actix-web ist ein leistungsfähiges, pragmatisches und äußerst schnelles Webframework für Rust.

Es basiert auf Actix, einem Actor-Framework. Sie müssen Actors jedoch nicht verstehen, um Actix-web effektiv zu verwenden. Das Framework ist für asynchrone Operationen ausgelegt und eignet sich daher ideal für I/O-gebundene Aufgaben wie die Verarbeitung vieler gleichzeitig eingehender API-Anfragen.

Actix-web bietet Werkzeuge für Routing, die Verarbeitung von Anfragen und Antworten, Middleware und vieles mehr und vereinfacht so die Erstellung komplexer APIs.

Projekteinrichtung und Abhängigkeiten

Zunächst erstellen wir ein neues Rust-Projekt und fügen die erforderlichen Abhängigkeiten hinzu. Wir verwenden actix-web als Framework und serde zum Serialisieren und Deserialisieren von JSON-Daten.

Erstellen Sie zunächst ein neues Projekt:

cargo new my_rest_api --bin

Fügen Sie anschließend diese Zeilen im Abschnitt [dependencies] zu Ihrer Datei Cargo.toml hinzu:

[dependencies]
actix-web = "4"
serde = { version = "1.0", features = ["derive"] }

Ihr erster Actix-web-Server

Schreiben wir einen minimalen Actix-web-Server. Dieser Code richtet die grundlegende Struktur ein, um an Port 8080 auf eingehende HTTP-Anfragen zu warten. Er verarbeitet noch keine bestimmten Routen, bildet aber die Grundlage.

Das Makro #[actix_web::main] macht unsere async fn main mit der Laufzeitumgebung von Actix-web kompatibel.

use actix_web::{App, HttpServer};

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        // Our application instance, where we'll add routes
        App::new()
    })
    .bind(("127.0.0.1", 8080))? // Bind to an IP address and port
    .run() // Start the server
    .await // Await its completion
}

Eine GET-Route definieren

Fügen wir unserem Server nun eine einfache Route hinzu. Eine Route ordnet den Pfad und die Methode einer eingehenden HTTP-Anfrage (etwa GET /hello) einer bestimmten Handler-Funktion zu.

Unsere Handler-Funktion hello_world gibt einfach eine Zeichenkette zurück. web::get().to() registriert diesen Handler für GET-Anfragen an den Pfad /hello.

use actix_web::{web, App, HttpServer, Responder};

// A handler function that returns a simple string response
async fn hello_world() -> impl Responder {
    "Hello, Actix-web!"
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // Register our route: GET /hello maps to hello_world()
            .route("/hello", web::get().to(hello_world))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Pfadparameter für dynamische Routen

APIs müssen häufig dynamische Teile einer URL verarbeiten, etwa eine ID oder einen Namen. Actix-web verwendet Pfadparameter, um diese Werte zu erfassen.

Wir definieren einen Platzhalter in der Route (z. B. /{name}). Im Handler verwenden wir web::Path<String> (oder einen anderen deserialisierbaren Typ), um den Wert zu extrahieren.

use actix_web::{web, App, HttpServer, Responder};

// Handler function with a path parameter 'name'
async fn greet_name(name: web::Path<String>) -> impl Responder {
    format!("Hello, {}!", name.into_inner())
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // Route with a dynamic path segment for a name
            .route("/greet/{name}", web::get().to(greet_name))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

POST-Anfragen und JSON verarbeiten

Zum Erstellen oder Aktualisieren von Ressourcen verwenden wir POST- oder PUT-Anfragen und senden Daten häufig als JSON im Anfragerumpf.

Actix-web vereinfacht die Verarbeitung von JSON mit web::Json<T>. Wir definieren eine Rust-struct, die der erwarteten JSON-Struktur entspricht, leiten Deserialize von serde ab, und Actix-web analysiert das eingehende JSON automatisch in unsere Struct.

use actix_web::{web, App, HttpServer, Responder};
use serde::{Deserialize, Serialize};

// Define a struct to represent our incoming JSON data
#[derive(Deserialize, Serialize)]
struct User {
    username: String,
    email: String,
}

// Handler for POST requests that accepts a JSON User object
async fn create_user(user: web::Json<User>) -> impl Responder {
    // In a real app, you'd save this user to a database
    format!("User created: {} ({})", user.username, user.email)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // POST /users expects a JSON body and maps to create_user()
            .route("/users", web::post().to(create_user))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Eine einfache API mit Zustand erstellen

Führen wir nun das Gelernte zusammen und erstellen eine kleine API, die eine Benutzerliste im Speicher verwaltet. Mit web::Data stellen wir anwendungsspezifischen Zustand (unsere Benutzerliste) mehreren Handlern zur Verfügung.

std::sync::Mutex ermöglicht den sicheren veränderbaren Zugriff auf unser Vec<User> aus mehreren gleichzeitig ausgeführten Anfragen. Wir stellen Endpunkte für GET /users und POST /users bereit.

use actix_web::{web, App, HttpServer, Responder, HttpResponse};
use serde::{Deserialize, Serialize};
use std::sync::Mutex; // For shared mutable state

// Define a User struct that can be serialized/deserialized and cloned
#[derive(Deserialize, Serialize, Clone)]
struct User {
    id: u32,
    username: String,
    email: String,
}

// Application state to hold our users and track next ID
struct AppState {
    users: Mutex<Vec<User>>,
    next_id: Mutex<u32>,
}

// Handler to get all users
async fn get_users(data: web::Data<AppState>) -> impl Responder {
    let users = data.users.lock().unwrap(); // Acquire a lock
    web::Json(users.clone()) // Return users as JSON
}

// Handler to create a new user
async fn create_user(
    data: web::Data<AppState>,
    new_user: web::Json<User>,
) -> impl Responder {
    let mut users = data.users.lock().unwrap();
    let mut next_id = data.next_id.lock().unwrap();

    let user = User {
        id: *next_id,
        username: new_user.username.clone(),
        email: new_user.email.clone(),
    };
    users.push(user.clone());
    *next_id += 1; // Increment for the next user
    HttpResponse::Created().json(user) // Return 201 Created status and user
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    // Create shared application state
    let app_state = web::Data::new(AppState {
        users: Mutex::new(vec![]), // Initialize with an empty user list
        next_id: Mutex::new(1),    // Start IDs from 1
    });

    HttpServer::new(move || { // 'move' closure to capture app_state
        App::new()
            .app_data(app_state.clone()) // Register shared state with the app
            .route("/users", web::get().to(get_users))
            .route("/users", web::post().to(create_user))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Kurztest zu API-Konzepten

Sie haben gelernt, wie Sie einen grundlegenden Actix-web-Server einrichten und verschiedene HTTP-Anfragen verarbeiten. Testen wir Ihr Verständnis!

Zusammenfassung und nächste Schritte

Gut gemacht! Sie haben Ihre ersten Schritte beim Erstellen von RESTful APIs mit Rust und Actix-web gemacht.

Wir haben die Grundlagen von REST-APIs und die Gründe für Rusts Eignung dafür behandelt.
Sie haben gelernt, ein grundlegendes Actix-web-Projekt einzurichten.
Wir haben das Definieren von GET- und POST-Routen behandelt.
Sie haben gesehen, wie sich Pfadparameter extrahieren und JSON-Nutzdaten verarbeiten lassen.
Abschließend haben Sie eine einfache API erstellt, die mit web::Data im Speicher gehaltenen Zustand verwaltet.

Als Nächstes befassen Sie sich eingehender mit der Datenbankanbindung und einer robusten Fehlerbehandlung, um noch leistungsfähigere und produktionsreife Webdienste zu erstellen!

Häufig gestellte Fragen

Ist die Lektion „REST-APIs mit Actix-web/Rocket“ kostenlos?

Ja — der vollständige Text von „REST-APIs mit Actix-web/Rocket“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „REST-APIs mit Actix-web/Rocket“?

Entwickeln Sie RESTful APIs mit einem modernen Rust-Webframework wie Actix-web oder Rocket und verarbeiten Sie Routen, Anfragen und Antworten. Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 3.

Wie lange dauert die Lektion „REST-APIs mit Actix-web/Rocket“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding