HTTP-Client in Rust: Anfragen richtig stellen

HTTP-Client in Rust: Anfragen richtig stellen

Rust ist eine moderne Systemprogrammiersprache, die die Leistung von C++ mit Speichersicherheit kombiniert. Bei der Entwicklung von Webanwendungen, Microservices oder Kommandozeilen-Tools entsteht oft die Notwendigkeit, mit externen APIs zu interagieren. In diesem Artikel werden wir uns ansehen, wie man einen HTTP-Client in Rust erstellt, unter Verwendung der beliebten Crates reqwest und ureq. Sie erfahren, wie Sie GET- und POST-Anfragen senden, Fehler behandeln und mit JSON arbeiten.

Warum Rust für HTTP-Anfragen?

Rust bietet einzigartige Vorteile für die Arbeit mit Netzwerken:

• Speichersicherheit — der Compiler garantiert das Fehlen von Speicherlecks und Datenrennen.
• Hohe Leistung — die Geschwindigkeit ist vergleichbar mit C/C++.
• Asynchronität — integrierte Unterstützung für async/await für effiziente I/O-Arbeit.
• Crate-Ökosystem — Tausende fertiger Bibliotheken, einschließlich HTTP-Clients.

Für die Arbeit mit HTTP in Rust gibt es zwei Hauptansätze: synchron (blockierend) und asynchron (nicht blockierend). Wir werden uns beide ansehen.

Projekt einrichten und Crate auswählen

Erstellen wir ein neues Rust-Projekt:

cargo new rust-http-clientcd rust-http-client

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

[dependencies]# Für asynchrone Anfragenreqwest = { version = "0.12", features = ["json"] }tokio = { version = "1", features = ["full"] }

# Für synchrone Anfragen (Alternative)ureq = "2.9"

Vergleich der Crates:

• reqwest — der beliebteste HTTP-Client. Unterstützt Asynchronität, JSON, Cookies, Proxy.
• ureq — ein leichter synchroner Client. Ideal für einfache Skripte und CLI-Tools.

1. GET-Anfrage mit reqwest (asynchron)

Beginnen wir mit einer asynchronen GET-Anfrage. Erstellen Sie die Datei src/main.rs:

use reqwest;use std::error::Error;

#[tokio::main]async fn main() -> Result<(), Box<dyn Error>> {    // Sende eine GET-Anfrage    let response = reqwest::get("https://api.github.com/repos/rust-lang/rust")        .await?        .text()        .await?;

    println!("Antwort von der GitHub API:");    println!("{}", &response[..500]); // Gib die ersten 500 Zeichen aus

    Ok(())}

Erklärung:

• #[tokio::main] — Makro zum Starten der Tokio-Laufzeitumgebung für asynchrone Ausführung.
• reqwest::get() — sendet eine GET-Anfrage und gibt eine Response zurück.
• .await? — wartet auf den Abschluss der Operation und behandelt Fehler.
• .text() — extrahiert den Antworttext als String.

Starten Sie das Projekt:

cargo run

Sie sehen die JSON-Antwort von der GitHub API.

2. POST-Anfrage mit JSON (reqwest)

Jetzt senden wir eine POST-Anfrage mit einem JSON-Body:

use reqwest;use serde::{Deserialize, Serialize};use std::error::Error;

#[derive(Serialize, Deserialize, Debug)]struct Post {    title: String,    body: String,    user_id: u32,}

#[derive(Deserialize, Debug)]struct CreatedPost {    id: u32,    title: String,}

#[tokio::main]async fn main() -> Result<(), Box<dyn Error>> {    // Erstelle einen Client mit Einstellungen    let client = reqwest::Client::new();

    // Daten zum Senden    let new_post = Post {        title: "HTTP-Client in Rust".to_string(),        body: "Vollständige Anleitung zur Arbeit mit HTTP in Rust".to_string(),        user_id: 1,    };

    // Sende eine POST-Anfrage    let response = client        .post("https://jsonplaceholder.typicode.com/posts")        .json(&new_post)        .send()        .await?;

    // 
```