Client HTTP en Rust : faire des requêtes correctement de A à Z

Introduction : Pourquoi Rust est un excellent choix pour les requêtes HTTP

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. Si vous développez une application réseau, un web scraper ou un microservice, savoir effectuer correctement des requêtes HTTP en Rust est une compétence indispensable. Dans cet article, nous allons voir comment créer un client HTTP complet en Rust en utilisant la bibliothèque reqwest, qui est la référence de facto pour travailler avec HTTP dans l'écosystème Rust.

Nous parcourrons le chemin allant de l'installation des dépendances à la gestion des erreurs et au travail avec JSON. À la fin de cet article, vous serez capable d'écrire des clients HTTP fiables et rapides en Rust qui ne vous décevront pas en production.

Installation et configuration du projet

La première étape consiste à créer un nouveau projet et à ajouter la dépendance reqwest avec le support de l'asynchrone et de JSON.

cargo new rust_http_client\ncd rust_http_client

Ouvrez Cargo.toml et ajoutez :

[dependencies]\nreqwest = { version = "0.12", features = ["json"] }\ntokio = { version = "1", features = ["full"] }\nserde = { version = "1", features = ["derive"] }\nserde_json = "1"

Expliquons chaque dépendance :

\n
• reqwest — le client HTTP principal. Le flag json active le support de la sérialisation/désérialisation.
\n
• tokio — le runtime asynchrone de Rust. Les requêtes HTTP dans reqwest sont asynchrones par défaut.
\n
• serde / serde_json — pour travailler avec JSON (structures, sérialisation).
\n

Maintenant, tout est prêt pour écrire le code.

Requête GET basique : récupérer des données du serveur

Commençons par une simple requête GET. Créons une fonction qui récupère des données depuis une API publique et les affiche dans la console.

use reqwest::Error;\n\n#[tokio::main]\nasync fn main() -> Result<(), Error> {\n    let url = "https://jsonplaceholder.typicode.com/posts/1";\n    let response = reqwest::get(url).await?;\n\n    println!("Statut : {}", response.status());\n\n    let body = response.text().await?;\n    println!("Corps de la réponse :\\n{}", body);\n\n    Ok(())\n}

Ce qui se passe ici :

\n
• Nous utilisons la macro #[tokio::main] pour lancer une fonction asynchrone.
\n
• reqwest::get(url).await? exécute une requête GET. Le signe ? propage l'erreur si la requête échoue.
\n
• response.status() retourne le statut HTTP (par exemple, 200 OK).
\n
• response.text().await? extrait le corps de la réponse sous forme de chaîne de caractères.
\n

Exécutez le code avec la commande cargo run. Vous verrez un objet JSON contenant les données du post.

Ajouter des en-têtes et des paramètres de requête

Dans les applications réelles, il est souvent nécessaire de transmettre des en-têtes (par exemple, une clé API) ou des paramètres de requête. Voici comment faire :

use reqwest::Client;\nuse std::collections::HashMap;\n\n#[tokio::main]\nasync fn main() -> Result<(), reqwest::Error> {\n    let client = Client::new();\n\n    let mut params = HashMap::new();\n    params.insert("userId", "1");\n\n    let response = client\n        .get("https://jsonplaceholder.typicode.com/posts")\n        .header("Accept", "application/json")\n        .query(&params)\n        .send()\n        .await?;\n\n    let posts: serde_json::Value = response.json().await?;\n    println!("Nombre de posts : {}", posts.as_array().unwrap().len());\n\n    Ok(())\n}

Points clés :

\n
• Nous créons un Client — c'est un client HTTP réutilisable avec un pool de connexions. Utilisez toujours Client au lieu d'appels directs à reqwest::get pour le code de production.
\n
• La méthode .header() ajoute un en-tête.
\n
• .query() prend un dictionnaire de paramètres et encode automatiquement l'URL.
\n
• .json() désérialise immédiatement la réponse en une valeur JSON.
\n