Hyper pour Rust : guide complet avec exemples

Qu'est-ce que Hyper et pourquoi l'utiliser

Hyper est une bibliothèque HTTP asynchrone haute performance pour le langage Rust, écrite en Rust. C'est l'une des bibliothèques les plus populaires et respectées de l'écosystème Rust pour travailler avec les protocoles HTTP/1 et HTTP/2. Hyper fournit à la fois des parties client et serveur, permettant aux développeurs de créer des applications web et des API rapides, sécurisées et efficaces.

Les principales raisons d'utiliser Hyper :

• Performance : Hyper est construit sur le runtime asynchrone Tokio et utilise des entrées-sorties non bloquantes, ce qui permet de gérer des milliers de connexions simultanées avec une consommation minimale de ressources.
• Sécurité : Rust garantit la sécurité mémoire à la compilation, et Hyper suit ces principes, minimisant les risques de fuites mémoire et de conditions de concurrence.
• Flexibilité : La bibliothèque offre un contrôle de bas niveau sur les connexions HTTP, permettant d'implémenter pratiquement n'importe quelle logique de traitement des requêtes.
• Compatibilité : Hyper sert de base à de nombreux autres frameworks Rust populaires, tels que Warp, Axum et Tide.
• Support HTTP/2 : Prise en charge intégrée de HTTP/2 pour une utilisation plus efficace des ressources réseau.

Hyper est idéal pour créer des microservices, des serveurs proxy, des passerelles API et toute autre application réseau où la vitesse et la fiabilité sont essentielles.

Installation de Hyper

L'installation de Hyper dans un projet Rust se fait via le gestionnaire de paquets Cargo. Ajoutez les dépendances suivantes dans le fichier Cargo.toml :

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

Explication des dépendances :

• hyper : La bibliothèque principale avec toutes les fonctionnalités activées (serveur, client, HTTP/2).
• tokio : Le runtime asynchrone nécessaire au fonctionnement de Hyper.
• serde et serde_json : Pour la sérialisation/désérialisation des données (utile dans les exemples).

Après avoir ajouté les dépendances, exécutez la commande cargo build pour télécharger et compiler les bibliothèques.

Démarrage rapide : un serveur HTTP simple

Créons un serveur HTTP minimal qui répond "Hello, World!" à toute requête. Créez un fichier src/main.rs avec le contenu suivant :

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};

// Définition du type pour notre service
struct HelloWorld;

impl Service<Request<Body>> for HelloWorld {
    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("Hello, World!"))
            .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("Hello, World!"))
            .unwrap();
        Ok::<_, Infallible>(response)
    }));

    println!("Serveur démarré sur http://{}", addr);
    server.await?;
    Ok(())
}

Pour lancer le serveur, exécutez cargo run dans votre terminal. Ouvrez votre navigateur et accédez à http://localhost:3000 pour voir le message "Hello, World!".