Hyper für Rust: Vollständige Anleitung mit Beispielen

Was ist Hyper und warum wird es benötigt

Hyper ist eine leistungsstarke asynchrone HTTP-Bibliothek für die Programmiersprache Rust, die selbst in Rust geschrieben wurde. Sie gehört zu den beliebtesten und angesehensten Bibliotheken im Rust-Ökosystem für die Arbeit mit HTTP/1- und HTTP/2-Protokollen. Hyper bietet sowohl Client- als auch Server-Komponenten und ermöglicht es Entwicklern, schnelle, sichere und effiziente Webanwendungen und APIs zu erstellen.

Die Hauptgründe für den Einsatz von Hyper:

• Leistung: Hyper basiert auf der asynchronen Laufzeitumgebung Tokio und nutzt nicht-blockierende Ein-/Ausgabe, wodurch tausende gleichzeitige Verbindungen mit minimalem Ressourcenverbrauch verarbeitet werden können.
• Sicherheit: Rust garantiert Speichersicherheit bereits zur Kompilierzeit, und Hyper folgt diesen Prinzipien, wodurch Risiken wie Speicherlecks und Datenrennen minimiert werden.
• Flexibilität: Die Bibliothek bietet eine niedrigschwellige Kontrolle über HTTP-Verbindungen und ermöglicht die Umsetzung nahezu jeder Anfrageverarbeitungslogik.
• Kompatibilität: Hyper ist die Grundlage für viele andere beliebte Rust-Frameworks wie Warp, Axum und Tide.
• HTTP/2-Unterstützung: Integrierte Unterstützung für HTTP/2 für eine effizientere Nutzung der Netzwerkressourcen.

Hyper eignet sich ideal für die Entwicklung von Microservices, Proxy-Servern, API-Gateways und allen anderen Netzwerkanwendungen, bei denen Geschwindigkeit und Zuverlässigkeit entscheidend sind.

Installation von Hyper

Die Installation von Hyper in einem Rust-Projekt erfolgt über den Paketmanager Cargo. Fügen Sie die folgenden Abhängigkeiten in Ihre Cargo.toml-Datei ein:

[dependencies]
hyper = { version = "1.5", features = ["full"] }
tokio = { version = "1", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

Erklärung der Abhängigkeiten:

• hyper: Die Hauptbibliothek mit allen aktivierten Funktionen (Server, Client, HTTP/2).
• tokio: Die asynchrone Laufzeitumgebung, die für Hyper erforderlich ist.
• serde und serde_json: Für die Serialisierung/Deserialisierung von Daten (wird in den Beispielen benötigt).

Nach dem Hinzufügen der Abhängigkeiten führen Sie den Befehl cargo build aus, um die Bibliotheken herunterzuladen und zu kompilieren.

Schnellstart: Ein einfacher HTTP-Server

Erstellen wir einen minimalen HTTP-Server, der auf jede Anfrage mit "Hallo, Welt!" antwortet. Erstellen Sie eine Datei src/main.rs mit folgendem Inhalt:

use hyper::service::{service_fn, Service};
use hyper::{Body, Request, Response, Server};
use std::convert::Infallible;
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

// Definiere den Typ für unseren Service
struct HalloWelt;

impl Service<Request<Body>> for HalloWelt {
    type Response = Response<Body>;
    type Error = Infallible;
    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;

    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, _req: Request<Body>) -> Self::Future {
        let response = Response::builder()
            .status(200)
            .header("Content-Type", "text/plain")
            .body(Body::from("Hallo, Welt!"))
            .unwrap();

        Box::pin(async { Ok(response) })
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let addr = ([127, 0, 0, 1], 3000).into();
    let server = Server::bind(&addr).serve(service_fn(|req| async move {
        let response = Response::builder()
            .status(200)
            .header("Content-Type", "text/plain")
            .body(Body::from("Hallo, Welt!"))
            .unwrap();
        Ok::<_, Infallible>(response)
    }));

    println!("Server läuft unter http://{}", addr);
    server.await?;
    Ok(())
}

Starten Sie den Server mit cargo run und öffnen Sie http://127.0.0.1:3000 in Ihrem Browser. Sie sollten die Nachricht "Hallo, Welt!" sehen.