HTTP-Client für Rust: Top-Bibliotheken

HTTP-Client für Rust: Überblick über die besten Bibliotheken

Rust ist eine systemnahe Programmiersprache, die aufgrund ihrer Sicherheit, Leistungsfähigkeit und des Fehlens eines Garbage Collectors an Popularität gewonnen hat. Bei der Entwicklung von Webanwendungen, Microservices oder Tools für die Arbeit mit APIs besteht häufig die Notwendigkeit, HTTP-Anfragen zu senden. In diesem Artikel betrachten wir die besten Bibliotheken für die Arbeit mit HTTP in Rust, ihre Besonderheiten, Leistung und Anwendungsbeispiele.

1. reqwest — der beliebteste HTTP-Client

reqwest ist ein hochwertiger, benutzerfreundlicher HTTP-Client für Rust, der auf hyper basiert. Er unterstützt sowohl synchrone als auch asynchrone Anfragen, automatische JSON-Verarbeitung, Cookies, Proxys und TLS.

Hauptfunktionen:

Unterstützung von async/await (erfordert tokio oder async-std)
Automatische Serialisierung/Deserialisierung von JSON (über serde)
Arbeit mit Formularen, multipart, Dateien
Verwaltung von Cookies und Sitzungen
Unterstützung von HTTP/2 und TLS (über native-tls oder rustls)

Beispiel einer GET-Anfrage mit reqwest:

use reqwest;

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

    let body = response.text().await?;    println!("Antwort: {}", body);    Ok(())}

Beispiel einer POST-Anfrage mit JSON:

use reqwest;use serde_json::json;

#[tokio::main]async fn main() -> Result<(), reqwest::Error> {    let client = reqwest::Client::new();    let payload = json!({"title": "Neue Aufgabe", "completed": false});

    let response = client        .post("https://jsonplaceholder.typicode.com/todos")        .json(&payload)        .send()        .await?;

    println!("Status: {}", response.status());    Ok(())}

2. ureq — minimalistisch und schnell

ureq ist ein leichtgewichtiger synchroner HTTP-Client ohne Abhängigkeiten von einer async-Runtime. Er ist ideal für Skripte, CLI-Tools und Projekte, die keine Asynchronität benötigen.

Besonderheiten:

Reine synchrone API
Minimale Anzahl von Abhängigkeiten
Unterstützung von JSON, multipart, Cookies
Integrierte TLS-Unterstützung (über native-tls oder rustls)

Beispiel mit ureq:

use ureq;

fn main() -> Result<(), ureq::Error> {    let response = ureq::get("https://httpbin.org/get")        .set("Accept", "application/json")        .call()?;

    let body: serde_json::Value = response.into_json()?;    println!("JSON: {}", body);    Ok(())}

3. hyper — niedrigschwelliges Fundament

hyper ist eine asynchrone HTTP-Bibliothek, auf der viele andere Clients (einschließlich reqwest) aufbauen. Sie bietet vollständige Kontrolle über Anfragen, erfordert jedoch mehr Code und Verständnis asynchroner Konzepte.

Wann hyper wählen:

Maximale Leistung erforderlich
Feinabstimmung von Verbindungen notwendig
Sie bauen einen eigenen HTTP-Server oder Proxy

Beispiel einer einfachen GET-Anfrage mit hyper:

use hyper::{Client, Uri};use hyper::body::HttpBody;

#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let client = Client::new();    let uri: Uri = "http://httpbin.org/ip".parse()?;    let mut response = client.get(uri).await?;

    while let Some(chunk) = response.body_mut().data().await {        let data = chunk?;        println!("{}", String::from_utf8_lossy(&data));    }    Ok(())}