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 dispose de fonctionnalités intégrées pour les opérations HTTP. Il existe également de nombreuses bibliothèques dans l’écosystème Rust qui vous aident à interagir avec HTTP et à construire des services HTTP.
Faire des requêtes HTTP avec Rust
Plusieurs bibliothèques Rust sont disponibles pour effectuer des requêtes HTTP, notamment les bibliothèques Reqwest, Hyper et Surf. Reqwest est la plus populaire parmi les développeurs Rust.
Reqwest est une bibliothèque client de haut niveau qui fournit une API simple et pratique pour effectuer des requêtes HTTP. Reqwest fournit des fonctionnalités pour envoyer des requêtes et gérer les réponses et les erreurs. Elle fait abstraction de nombreux détails liés à la formulation d’une requête HTTP et prend en charge des fonctionnalités avancées telles que les requêtes asynchrones à l’aide de la fonction tokio . Il gère également la désérialisation JSON, les en-têtes HTTP et les paramètres SSL. 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 êtes nouveau en Rust ou si vous manquez d’expérience avec les services HTTP.
Pour commencer avec Reqwest, ajoutez les bibliothèques Reqwest et Tokio 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 projet Cargo.toml après la création d’un projet Rust.
[dependencies]
tokio = { version = "1.15", features = ["full"] }
reqwest = { version = "0.11", features = ["json"] }
Une fois que vous avez ajouté les bibliothèques Reqwest et Tokio aux dépendances de votre projet, Cargo les installera lorsque vous compilerez 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 des fichiers binaires tels que des images ou des vidéos.
Reqwest vous permet de spécifier le point d’extrémité de l’URL sous la forme d’une chaîne, ainsi que les paramètres de requête et les en-têtes de la demande.
Voici comment envoyer une requête HTTP GET à une URL :
use reqwest::Error;
async fn get_request() -> Result<(), Error> {
let response = reqwest::get("https://www.example.com").await?;
println!("Status: {}", response.status());
let body = response.text().await?;
println!("Body:\n{}", body);
Ok(())
}
#[tokio::main]
async fn main() -> Result<(), Error> {
get_request().await?;
Ok(())
}
Ce code définit une fonction asynchrone, get_requestLa commande « get_request » permet d’imprimer les détails de la réponse à une requête adressée à example.com. Il appelle la fonction reqwest module’s obtenir et affiche le code d’état et le corps de la réponse.
Voici le résultat de l’appel à la méthode get_request de la fonction principal fonction :
Gestion des erreurs HTTP avec Reqwest
Vous aurez besoin de gérer les erreurs des requêtes HTTP lorsqu’elles surviennent. La bibliothèque Reqwest fournit une fonction Erreur que vous pouvez utiliser pour gérer les erreurs. En outre, les codes d’état HTTP du serveur web peuvent fournir des informations sur l’état de la requête.
Voici comment vous pouvez gérer les erreurs HTTP pour vos demandes avec Reqwest :
use reqwest::Error;
async fn handle_error() -> Result<(), Error> {
let response = reqwest::get("https://www.example.com").await?;
match response.status().as_u16() {
200..=299 => {
let body = response.text().await?;
println!("Success! Body:\n{}", body);
}
400..=599 => {
let status = response.status();
let error_message = response.text().await?;
println!("Error {}: {}", status, error_message);
}
_ => {
println!("Unexpected status code: {}", response.status());
}
}
Ok(())
}
#[tokio::main]
async fn main() -> Result<(), Error> {
handle_error().await?;
Ok(())
}
L’outil handle_error La fonction GET effectue une requête GET vers example.com, et l’instruction match gère 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 allez effectuer des requêtes HTTP POST pour soumettre des données à un serveur. Vous pouvez le faire en utilisant l’option reqwest::Client qui crée un client et utilise la structure reqwest::RequestBuilder struct pour construire la requête.
Voici comment effectuer une requête POST vers le point d’arrivée POST de HTTPbin avec Reqwest :
use reqwest::{Client, Error};
async fn post_it() -> Result<(), Error> {
let url = "https://httpbin.org/post";
let json_data = r#"{"name": "John Doe", "email": "john.doe@example.com"}"#;
let client = reqwest::Client::new();
let response = client
.post(url)
.header("Content-Type", "application/json")
.body(json_data.to_owned())
.send()
.await?;
println!("Status: {}", response.status());
let response_body = response.text().await?;
println!("Response body:\n{}", response_body);
Ok(())
}
#[tokio::main]
async fn main() -> Result<(), Error> {
post_it().await?;
Ok(())
}
Le json_data définit les données JSON de la requête, et la variable client La variable est un reqwest::Client instance pour la requête POST.
L’instance réponse La variable est le constructeur de la requête POST. La variable post envoie la requête POST à l’URL, et la méthode l’en-tête définit un en-tête HTTP. La méthode corps définit le corps de la requête, et la méthode envoyer envoie la requête.
La méthode post_it imprime le code d’état et le corps de la réponse sur la console à l’aide de la fonction println ! macro :
Gestion des en-têtes et des paramètres de requête Vos requêtes HTTP
La gestion des en-têtes et des paramètres de requête est un aspect important des requêtes HTTP. Les en-têtes contiennent des informations supplémentaires telles que les identifiants d’authentification ou des métadonnées sur le contenu demandé.
Vous utiliserez les paramètres de requête pour ajouter des informations supplémentaires à une URL afin que le serveur puisse filtrer ou modifier une réponse.
La gestion des en-têtes et des paramètres de requête suit un processus similaire à l’envoi de requêtes postales. Voici comment vous pouvez gérer les en-têtes et les paramètres de requête dans vos requêtes HTTP avec Reqwest :
use std::collections::HashMap;
use reqwest::{ Error, header};
#[tokio::main]
async fn main() -> Result<(), Error> {
headers_for_requests().await?;
Ok(())
}
async fn headers_for_requests() -> Result<(), Error> {
// Set up the URL and headers for the request
let url = "https://example.com/api";
let mut headers = header::HeaderMap::new();
headers.insert(header::USER_AGENT, header::HeaderValue::from_static("reqwest"));
headers.insert(header::CONTENT_TYPE, header::HeaderValue::from_static("application/json"));
// Set up the query parameters for the request
let mut params = HashMap::new();
params.insert("foo", "bar");
params.insert("baz", "qux");
// Make the request
let response = reqwest::Client::new()
.get(url)
.headers(headers)
.query(¶ms)
.send()
.await?;
// Handle the response
println!("{:#?}", response);
Ok(())
}
Vous créerez un hashmap pour les paramètres de la requête que vous passerez ensuite à la fonction requête méthode. Créer une instance de la méthode header::HeaderMap type pour ajouter des en-têtes.
Le en-têtes_pour_requêtes envoie une requête GET à example.com avec plusieurs en-têtes et paramètres de requête. Elle utilise l’en-tête en-têtes et requête qui prennent des cartes contenant respectivement les en-têtes et les paramètres de la requête.
La création d’une application Web Full Stack en Rust avec WASM
Faire des requêtes HTTP est une compétence qui est pratique pour construire des applications sophistiquées qui intègrent des fonctionnalités d’autres applications.
Vous pouvez construire des applications web complètes en Rust avec des bibliothèques comme Percy, Yew, et Sycamore qui abstraient les complexités pour une excellente expérience de développement.
