Fazendo solicitações HTTP em Rust com Reqwest

Como a maioria das linguagens de programação, você pode usar Rust para enviar e receber dados por HTTP. Ao criar um serviço baseado na Web, muitas vezes você precisará integrar um ou mais serviços. Muitas vezes, você fará isso enviando solicitações HTTP.

Rust possui funcionalidade integrada para operações HTTP. Também existem muitas bibliotecas no ecossistema Rust que ajudam você a interagir com HTTP e criar serviços HTTP.

Fazendo solicitações HTTP com Rust

Várias bibliotecas Rust estão disponíveis para fazer solicitações HTTP, incluindo o Solicitar, Hiper, e surfar bibliotecas. Reqwest é o mais popular entre os desenvolvedores Rust.

Reqwest é uma biblioteca cliente de alto nível que fornece uma API simples e conveniente para fazer solicitações HTTP. Reqwest fornece funcionalidade para enviar solicitações e lidar com respostas e erros. Ele abstrai muitos detalhes por trás de fazer uma solicitação HTTP e oferece suporte a recursos avançados como solicitações assíncronas usando o

Tóquio tempo de execução. Ele também lida com a desserialização JSON, cabeçalhos HTTP, tempos limite de conexão e configurações SSL.

Você achará a biblioteca Reqwest útil se for novo no Rust ou não tiver experiência com serviços HTTP.

Para começar com Reqwest, adicione Reqwest e Tóquio bibliotecas para as dependências do seu projeto. Tokio é uma biblioteca de tempo de execução assíncrona que interopera com Reqwest. Você pode adicionar essas dependências ao seu Cargo.toml depois de criar um projeto Rust.

[dependências]
Tóquio = { versão = "1.15", características = ["completo"] }
pedir = { versão = "0.11", características = ["json"] }

Depois de adicionar as bibliotecas Reqwest e Tokio às dependências do seu projeto, o Cargo as instalará quando você criar seu programa.

Solicitações HTTP GET com Reqwest

Você fará solicitações GET para recuperar dados de um servidor web. As solicitações GET podem recuperar páginas HTML, dados JSON ou arquivos binários como imagens ou vídeos.

Reqwest permite que você especifique o endpoint de URL como uma string junto com parâmetros de consulta e cabeçalhos para a solicitação.

Veja como você pode enviar uma solicitação HTTP GET para um URL:

usar requisição:: Erro;
assíncronofnget_request() -> Resultado {
deixar resposta = reqoeste:: get(" https://www.example.com").aguardam?;
println!("Status: {}", resposta.status());
deixar corpo = resposta.texto().aguardam?;
println!("Corpo:\n{}", corpo);
OK(())
}
#[tóquio:: principal]
assíncronofnprincipal() -> Resultado {
 get_request().aguardam?;
OK(())
}

Este código define uma função assíncrona, get_request, para imprimir detalhes de resposta de uma solicitação para example.com. Ele chama o pedir do módulo pegar método e imprime o código de status da resposta e corpo.

Aqui está o resultado de chamar o get_request função do principal função:

Lidando com erros HTTP com Reqwest

Você precisará lidar com erros de solicitações HTTP quando eles surgirem. A biblioteca Reqwest fornece uma Erro tipo que você pode usar para lidar com erros. Além disso, os códigos de status HTTP do servidor da Web podem fornecer informações sobre o status da solicitação.

Veja como você pode lidar com erros de HTTP para suas solicitações com Reqwest:

usar requisição:: Erro;
assíncronofnhandle_error() -> Resultado {
deixar resposta = reqoeste:: get(" https://www.example.com").aguardam?;
corresponder response.status().as_u16() {
200..=299 => {
deixar corpo = resposta.texto().aguardam?;
println!("Sucesso! Corpo:\n{}", corpo);
 }
400..=599 => {
deixar status = resposta.status();
deixar mensagem_erro = resposta.texto().aguardam?;
println!("Erro {}: {}", status, mensagem_erro);
 }
 _ => {
println!("Código de status inesperado: {}", resposta.status());
 }
 }
OK(())
}
#[tóquio:: principal]
assíncronofnprincipal() -> Resultado {
 handle_error().aguardam?;
OK(())
}

O handle_error função faz uma solicitação GET para exemplo.com, e a instrução de correspondência manipula quaisquer erros com base no código de status de resposta.

A função imprime uma mensagem e o código de status dependendo da resposta ao servidor.

Enviando solicitações HTTP POST com Reqwest

Você fará solicitações HTTP POST para enviar dados a um servidor. Você pode fazer isso usando o requisição:: Cliente struct que cria um cliente e usa o pedido:: RequestBuilder struct para criar a solicitação.

Veja como você pode fazer uma solicitação POST para Terminal de solicitação POST do HTTPbin com Reqwest:

usar reqwest::{Cliente, Erro};
assíncronofnpost_it() -> Resultado {
deixar URL = " https://httpbin.org/post";
deixar json_data = r#"{"nome": "John Doe", "email": "[email protected]"}"#;
deixar cliente = reqwest:: Cliente:: new();
deixar resposta = cliente
 .post (url)
 .cabeçalho("Tipo de conteúdo", "aplicativo/json")
 .body (json_data.to_owned())
 .enviar()
 .aguardam?;
println!("Status: {}", resposta.status());
deixar corpo_resposta = resposta.texto().aguardam?;
println!("Corpo da resposta:\n{}", resposta_corpo);
OK(())
}
#[tóquio:: principal]
assíncronofnprincipal() -> Resultado {
 post_it().aguardam?;
OK(())
}

O json_data variável define os dados JSON para a solicitação e o cliente variável é um requisição:: Cliente instância para a solicitação POST.

O resposta variável é o construtor de solicitação POST. O publicar método envia a solicitação POST para a URL e o cabeçalho O método define um cabeçalho HTTP. O corpo O método define o corpo da solicitação e o enviar método envia a solicitação.

O post_it A função imprime o código de status da resposta e o corpo no console usando o println! macro:

Manipulando Cabeçalhos e Parâmetros de Consulta Suas Solicitações HTTP

A manipulação de cabeçalhos e parâmetros de consulta é um aspecto importante ao fazer solicitações HTTP. Os cabeçalhos contêm informações adicionais, como credenciais de autenticação ou metadados sobre o conteúdo solicitado.

Você usará parâmetros de consulta para adicionar informações adicionais a uma URL para o servidor filtrar ou modificar uma resposta.

A manipulação de cabeçalhos e parâmetros de consulta segue um processo semelhante ao envio de solicitações de postagem. Veja como você pode lidar com cabeçalhos e parâmetros de consulta em suas solicitações HTTP com Reqwest:

usar std:: coleções:: HashMap;
usar reqwest::{ Erro, cabeçalho};
#[tóquio:: principal]
assíncronofnprincipal() -> Resultado {
 headers_for_requests().aguardam?;
OK(())
}
assíncronofnheaders_for_requests() -> Resultado {
// Configure a URL e os cabeçalhos para a solicitação
deixar URL = " https://example.com/api";
deixarmudo headers = header:: HeaderMap:: new();
 headers.insert (cabeçalho:: USER_AGENT, cabeçalho:: HeaderValue:: from_static("pedir"));
 headers.insert (cabeçalho:: CONTENT_TYPE, cabeçalho:: HeaderValue:: from_static("aplicativo/json"));
// Configure os parâmetros de consulta para a solicitação
deixarmudo params = HashMap:: new();
 params.insert("foo", "bar");
 params.insert("baz", "qux");
//Faça o pedido
deixar resposta = reqwest:: Cliente:: new()
 .get (url)
 .cabeçalhos (cabeçalhos)
 .query(&params)
 .enviar()
 .aguardam?;
// Trata a resposta
println!("{:#?}", resposta);
OK(())
}

Você criará um hashmap para os parâmetros de consulta que passará para o consulta método. Crie uma instância do cabeçalho:: HeaderMap digite para adicionar cabeçalhos.

O headers_for_requests função envia uma solicitação GET para exemplo.com com vários cabeçalhos e parâmetros de consulta. Ele usa o cabeçalhos e consulta métodos que recebem mapas contendo os cabeçalhos e parâmetros de consulta, respectivamente.

Você pode construir WebApp Full Stack em Rust com WASM

Fazer solicitações HTTP é uma habilidade útil para criar aplicativos sofisticados que integram a funcionalidade de outros aplicativos.

Você pode criar aplicativos Web de pilha completa em Rust com bibliotecas como Percy, Yew e Sycamore que abstraem complexidades para uma excelente experiência de desenvolvimento.