Faire des requêtes HTTP dans Rust avec Reqwest

Comme la plupart des langages de programmation, vous pouvez utiliser Rust pour envoyer et recevoir des données via HTTP. Lorsque vous créez un service Web, vous devez souvent intégrer un ou plusieurs services. Vous le ferez souvent en leur envoyant des requêtes HTTP.

Rust a une fonctionnalité intégrée pour les opérations HTTP. Il existe également de nombreuses bibliothèques dans l'écosystème Rust qui vous aident à interagir avec HTTP et à créer des services HTTP.

Faire des requêtes HTTP avec Rust

Plusieurs bibliothèques Rust sont disponibles pour effectuer des requêtes HTTP, y compris le Reqwest, Hyper, et Le surf bibliothèques. Reqwest est le plus populaire parmi les développeurs Rust.

Reqwest est une bibliothèque cliente de haut niveau qui fournit une API simple et pratique pour effectuer des requêtes HTTP. Reqwest fournit des fonctionnalités pour envoyer des demandes et gérer les réponses et les erreurs. Il résume de nombreux détails derrière la création d'une requête HTTP et prend en charge des fonctionnalités avancées telles que les requêtes asynchrones utilisant le

Tokyo Durée. Il gère également la désérialisation JSON, les en-têtes HTTP, les délais de connexion et les paramètres SSL.

Vous trouverez la bibliothèque Reqwest pratique si vous débutez avec Rust ou si vous manquez d'expérience avec les services HTTP.

Pour commencer avec Reqwest, ajoutez le Reqwest et Tokyo bibliothèques aux dépendances de votre projet. Tokio est une bibliothèque d'exécution asynchrone qui interagit avec Reqwest. Vous pouvez ajouter ces dépendances à votre Cargaison.toml fichier après avoir créé un projet Rust.

[dépendances]
Tokyo = { version = "1.15", caractéristiques = ["complet"] }
demande = { version = "0.11", caractéristiques = ["json"] }

Une fois que vous avez ajouté les bibliothèques Reqwest et Tokio aux dépendances de votre projet, Cargo les installera lors de la construction de votre programme.

Requêtes HTTP GET avec Reqwest

Vous ferez des requêtes GET pour récupérer des données à partir d'un serveur Web. Les requêtes GET peuvent récupérer des pages HTML, des données JSON ou fichiers binaires comme des images ou des vidéos.

Reqwest vous permet de spécifier le point de terminaison d'URL sous forme de chaîne avec les paramètres de requête et les en-têtes de la demande.

Voici comment envoyer une requête HTTP GET à une URL :

utiliser reqwest:: Erreur ;
asynchronefnget_request() -> Résultat {
laisser réponse = reqwest:: get(" https://www.example.com").attendre?;
imprimez !("Statut: {}", réponse.status());
laisser corps = réponse.text().attendre?;
imprimez !("Corps :\n{}", corps);
D'accord(())
}
#[tokio:: main]
asynchronefnprincipal() -> Résultat {
 get_request().attendre?;
D'accord(())
}

Ce code définit une fonction asynchrone, get_request, pour imprimer les détails de la réponse d'une demande à example.com. Il appelle le demande modules obtenir méthode et imprime la code d'état de la réponse et le corps.

Voici le résultat de l'appel du get_request fonction de la principal fonction:

Gestion des erreurs HTTP avec Reqwest

Vous devrez gérer les erreurs des requêtes HTTP lorsqu'elles surviennent. La bibliothèque Reqwest fournit une Erreur type que vous pouvez utiliser pour gérer les erreurs. De plus, les codes d'état HTTP du serveur Web peuvent fournir des informations sur l'état de la demande.

Voici comment vous pouvez gérer les erreurs HTTP pour vos requêtes avec Reqwest :

utiliser reqwest:: Erreur ;
asynchronefnhandle_error() -> Résultat {
laisser réponse = reqwest:: get(" https://www.example.com").attendre?;
correspondre réponse.status().as_u16() {
200..=299 => {
laisser corps = réponse.text().attendre?;
imprimez !("Succès! Corps :\n{}", corps);
 }
400..=599 => {
laisser status = réponse.status();
laisser message_erreur = réponse.texte().attendre?;
imprimez !("Erreur {}: {}", état, message_erreur);
 }
 _ => {
imprimez !("Code d'état inattendu: {}", réponse.status());
 }
 }
D'accord(())
}
#[tokio:: main]
asynchronefnprincipal() -> Résultat {
 handle_error().attendre?;
D'accord(())
}

Le handle_error la fonction envoie une requête GET à exemple.com, et l'instruction match gère toutes les erreurs en fonction du code d'état de la réponse.

La fonction imprime un message et le code d'état en fonction de la réponse au serveur.

Envoi de requêtes HTTP POST avec Reqwest

Vous ferez des requêtes HTTP POST pour soumettre des données à un serveur. Vous pouvez le faire en utilisant le demande:: Client struct qui crée un client et utilise le requête:: RequestBuilder struct pour construire la requête.

Voici comment vous pouvez faire une requête POST pour Point de terminaison de requête POST de HTTPbin avec Reqwest :

utiliser reqwest ::{Client, Erreur} ;
asynchronefnpost_it() -> Résultat {
laisser URL = " https://httpbin.org/post";
laisser json_data = r#"{"name": "John Doe", "email": "[email protected]"}"#;
laisser client = reqwest:: Client:: new();
laisser réponse = client
 .post (url)
 .entête("Type de contenu", "applications/json")
 .body (json_data.to_owned())
 .envoyer()
 .attendre?;
imprimez !("Statut: {}", réponse.status());
laisser response_body = réponse.text().attendre?;
imprimez !("Corps de la réponse :\n{}", corps_réponse);
D'accord(())
}
#[tokio:: main]
asynchronefnprincipal() -> Résultat {
 post_it().attendre?;
D'accord(())
}

Le json_data définit les données JSON pour la requête, et la client la variable est une demande:: Client instance pour la requête POST.

Le réponse variable est le générateur de requête POST. Le poste envoie la requête POST à ​​l'URL, et la méthode entête La méthode définit un en-tête HTTP. Le corps La méthode définit le corps de la requête et la envoyer méthode envoie la requête.

Le post_it fonction imprime le code d'état de la réponse et le corps de la console à l'aide de la imprimez ! macro :

Gestion des en-têtes et des paramètres de requête de vos requêtes HTTP

La gestion des en-têtes et des paramètres de requête est un aspect important de la création de requêtes HTTP. Les en-têtes contiennent des informations supplémentaires telles que les identifiants d'authentification ou les métadonnées sur le contenu demandé.

Vous utiliserez des paramètres de requête pour ajouter des informations supplémentaires à une URL afin que le serveur filtre ou modifie une réponse.

La gestion des en-têtes et des paramètres de requête suit un processus similaire à l'envoi de demandes de publication. Voici comment vous pouvez gérer les en-têtes et les paramètres de requête dans vos requêtes HTTP avec Reqwest :

utiliser std:: collections:: HashMap;
utiliser reqwest ::{ Erreur, en-tête} ;
#[tokio:: main]
asynchronefnprincipal() -> Résultat {
 headers_for_requests().attendre?;
D'accord(())
}
asynchronefnheaders_for_requests() -> Résultat {
// Configurer l'URL et les en-têtes de la requête
laisser URL = " https://example.com/api";
laissermuet headers = header:: HeaderMap:: new();
 headers.insert (en-tête:: USER_AGENT, en-tête:: HeaderValue:: from_static("reqwest"));
 headers.insert (en-tête:: CONTENT_TYPE, en-tête:: HeaderValue:: from_static("applications/json"));
// Configurer les paramètres de requête pour la requête
laissermuet params = HashMap:: new();
 params.insert("fou", "bar");
 params.insert("baz", "quux");
// Faire la requête
laisser réponse = reqwest:: Client:: new()
 .get (url)
 .headers (en-têtes)
 .query(&params)
 .envoyer()
 .attendre?;
// Traite la réponse
imprimez !("{:#?}", réponse);
D'accord(())
}

Vous allez créer une table de hachage pour les paramètres de requête que vous transmettez ensuite au mettre en doute méthode. Créer une instance de en-tête:: HeaderMap tapez pour ajouter des en-têtes.

Le headers_for_requests la fonction envoie une requête GET à exemple.com avec plusieurs en-têtes et paramètres de requête. Il utilise le en-têtes et mettre en doute méthodes qui prennent des cartes contenant les en-têtes et les paramètres de requête, respectivement.

Vous pouvez créer une application Web Full Stack dans Rust avec WASM

Faire des requêtes HTTP est une compétence pratique pour créer des applications sophistiquées qui intègrent des fonctionnalités d'autres applications.

Vous pouvez créer des applications Web complètes dans Rust avec des bibliothèques telles que Percy, Yew et Sycamore qui résument les complexités pour une excellente expérience de développement.