#Reqwest : Bibliothèque cliente HTTP Rust

Reqwest est une bibliothèque cliente HTTP de haut niveau qui simplifie le traitement des requêtes HTTP et fournit de nombreuses fonctionnalités couramment utilisées :

• Prise en charge des API asynchrones et bloquantes
• Gestion de différents types de corps de requête : texte brut, JSON, formulaires encodés en URL, formulaires multipart
• Politiques de redirection personnalisables
• Prise en charge des proxys HTTP
• Chiffrement TLS activé par défaut
• Gestion des cookies

#Utilisation de base

#Effectuer une requête GET

Pour des requêtes uniques, vous pouvez utiliser la méthode pratique get :

let body = reqwest::get("https://www.rust-lang.org")
    .await?
    .text()
    .await?;

println!("body = {body:?}");

Remarque : Si vous prévoyez d'effectuer plusieurs requêtes, il est préférable de créer un Client et de le réutiliser pour bénéficier du regroupement de connexions.

let client = reqwest::Client::new();
let res = client.get("https://www.rust-lang.org")
    .send()
    .await?;

#Effectuer une requête POST

Vous pouvez définir le corps de la requête en utilisant la méthode body() :

let client = reqwest::Client::new();
let res = client.post("http://httpbin.org/post")
    .body("le corps exact qui est envoyé")
    .send()
    .await?;

#Données de formulaire

L'envoi de données de formulaire est une exigence courante. Vous pouvez utiliser tout type pouvant être sérialisé en données de formulaire :

// Ceci enverra une requête POST avec un corps de `foo=bar&baz=quux`
let params = [("foo", "bar"), ("baz", "quux")];
let client = reqwest::Client::new();
let res = client.post("http://httpbin.org/post")
    .form(&params)
    .send()
    .await?;

#Données JSON

Vous pouvez facilement envoyer des données JSON en utilisant la méthode json (nécessite la fonctionnalité json) :

// Ceci enverra une requête POST avec un corps de `{"lang":"rust","body":"json"}`
let mut map = HashMap::new();
map.insert("lang", "rust");
map.insert("body", "json");

let client = reqwest::Client::new();
let res = client.post("http://httpbin.org/post")
    .json(&map)
    .send()
    .await?;

#Traitement des réponses

Les réponses peuvent être traitées de différentes manières :

let res = client.get("https://www.rust-lang.org").send().await?;

// Obtenir le code d'état
let status = res.status();

// Obtenir les en-têtes de réponse
let content_type = res.headers().get("content-type").unwrap();

// Lire le corps de la réponse sous forme de texte
let body = res.text().await?;

// Ou le parser en JSON
let json: serde_json::Value = res.json().await?;

#Fonctionnalités avancées

#Politique de redirection

Par défaut, le client gérera automatiquement les redirections HTTP, en suivant jusqu'à 10 sauts. Vous pouvez personnaliser ce comportement en utilisant ClientBuilder :

let custom_client = reqwest::Client::builder()
    .redirect(reqwest::redirect::Policy::none()) // Désactiver les redirections
    .build()?;

#Prise en charge des cookies

Vous pouvez activer le stockage et l'envoi automatiques des cookies de session via ClientBuilder :

let client = reqwest::Client::builder()
    .cookie_store(true)
    .build()?;

#Configuration du proxy

Les proxys système sont activés par défaut, ce qui recherchera les paramètres de proxy HTTP ou HTTPS dans les variables d'environnement :

• HTTP_PROXY ou http_proxy : proxy pour les connexions HTTP
• HTTPS_PROXY ou https_proxy : proxy pour les connexions HTTPS
• ALL_PROXY ou all_proxy : proxy pour les deux types de connexions

Vous pouvez également définir explicitement un proxy via le code :

let proxy = reqwest::Proxy::http("https://secure.example")?;
let client = reqwest::Client::builder()
    .proxy(proxy)
    .build()?;

// Ou désactiver les proxys
let client = reqwest::Client::builder()
    .no_proxy()
    .build()?;

#Configuration TLS

Le client utilise TLS par défaut pour se connecter aux cibles HTTPS :

// Ajouter des certificats serveur supplémentaires
let cert = reqwest::Certificate::from_pem(&cert_bytes)?;
let client = reqwest::Client::builder()
    .add_root_certificate(cert)
    .build()?;

// Configurer les certificats clients
let identity = reqwest::Identity::from_pkcs12_der(&pkcs12_der, "motdepasse")?;
let client = reqwest::Client::builder()
    .identity(identity)
    .build()?;

#Paramètres de délai d'attente

Vous pouvez configurer les durées de délai d'attente pour les requêtes :

let client = reqwest::Client::builder()
    .timeout(std::time::Duration::from_secs(10))
    .build()?;

#Fonctionnalités optionnelles

Reqwest fournit diverses fonctionnalités optionnelles qui peuvent être activées ou désactivées via les fonctionnalités Cargo :

• http2 (activé par défaut) : prise en charge de HTTP/2
• default-tls (activé par défaut) : fournit la prise en charge TLS pour HTTPS
• rustls-tls : fournit la fonctionnalité TLS en utilisant rustls
• blocking : fournit une API cliente bloquante
• json : fournit la fonctionnalité de sérialisation et désérialisation JSON
• multipart : fournit la fonctionnalité de formulaire multipart
• cookies : fournit la prise en charge des sessions de cookies
• gzip, brotli, deflate, zstd : prise en charge de diverses décompressions de corps de réponse
• socks : fournit la prise en charge du proxy SOCKS5

#API bloquante

Lorsque les opérations asynchrones ne sont pas nécessaires, vous pouvez utiliser l'API bloquante (nécessite la fonctionnalité blocking) :

let body = reqwest::blocking::get("https://www.rust-lang.org")?.text()?;

let client = reqwest::blocking::Client::new();
let res = client.post("http://httpbin.org/post")
    .json(&map)
    .send()?;