Client HTTP pour Rust : top des bibliothèques

Client HTTP pour Rust : revue des meilleures bibliothèques

Rust est un langage de programmation système qui a gagné en popularité grâce à sa sécurité, ses performances et l'absence de ramasse-miettes. Lors du développement d'applications web, de microservices ou d'outils pour travailler avec des API, il est souvent nécessaire d'envoyer des requêtes HTTP. Dans cet article, nous examinerons les meilleures bibliothèques pour travailler avec HTTP en Rust, leurs fonctionnalités, leurs performances et des exemples d'utilisation.

1. reqwest — le client HTTP le plus populaire

reqwest est un client HTTP haut niveau et pratique pour Rust, construit sur hyper. Il prend en charge les requêtes synchrones et asynchrones, le traitement automatique du JSON, les cookies, les proxys et TLS.

Fonctionnalités principales :

Prise en charge d'async/await (nécessite tokio ou async-std)
Sérialisation/désérialisation automatique du JSON (via serde)
Travail avec les formulaires, multipart, fichiers
Gestion des cookies et des sessions
Prise en charge de HTTP/2 et TLS (via native-tls ou rustls)

Exemple de requête GET avec 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!("Réponse : {}", body);    Ok(())}

Exemple de requête POST avec JSON :

use reqwest;use serde_json::json;

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

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

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

2. ureq — minimaliste et rapide

ureq est un client HTTP synchrone léger sans dépendances d'exécution asynchrone. Il est idéal pour les scripts, les utilitaires CLI et les projets où l'asynchronisme n'est pas nécessaire.

Caractéristiques :

API synchrone pure
Nombre minimal de dépendances
Prise en charge de JSON, multipart, cookies
Prise en charge intégrée de TLS (via native-tls ou rustls)

Exemple avec 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 — fondation bas niveau

hyper est une bibliothèque HTTP asynchrone sur laquelle sont construits de nombreux autres clients (y compris reqwest). Elle offre un contrôle total sur les requêtes, mais nécessite plus de code et une compréhension des concepts asynchrones.

Quand choisir hyper :

Performance maximale requise
Réglage fin des connexions nécessaire
Vous construisez votre propre serveur HTTP ou proxy

Exemple de requête GET simple avec 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(())}