Cliente HTTP em Rust: fazendo requisições corretamente

Cliente HTTP em Rust: fazendo requisições corretamente

Rust é uma linguagem de programação de sistemas moderna que ganhou popularidade devido ao seu desempenho e segurança de memória. No entanto, muitos desenvolvedores acostumados com Python ou JavaScript se perguntam: como fazer requisições HTTP em Rust? Neste artigo, vamos explorar a criação de um cliente HTTP em Rust usando a biblioteca popular reqwest. Você aprenderá como fazer requisições GET e POST, processar JSON, gerenciar cabeçalhos e trabalhar com assincronicidade. Após a leitura, você será capaz de integrar com confiança um cliente HTTP em seus projetos Rust.

1. Instalação e configuração do ambiente

Para começar, vamos criar um novo projeto Rust e adicionar as dependências necessárias. Abra o terminal e execute:

cargo new http_client_rustcd http_client_rust

Agora edite o arquivo Cargo.toml, adicionando as seguintes dependências:

[dependencies]reqwest = { version = "0.11", features = ["json"] }tokio = { version = "1", features = ["full"] }serde = { version = "1.0", features = ["derive"] }serde_json = "1.0"

Vamos analisar cada biblioteca:

• reqwest — o cliente HTTP principal. A flag json adiciona suporte para serialização/desserialização JSON.
• tokio — runtime assíncrono, necessário para o reqwest funcionar em modo assíncrono.
• serde e serde_json — para trabalhar com estruturas JSON.

Após adicionar as dependências, execute cargo build para baixar e compilar todas as bibliotecas.

2. Requisição GET básica

Vamos começar com uma requisição GET simples para uma API pública. Criaremos uma estrutura para a resposta e faremos a requisição ao serviço JSONPlaceholder:

use reqwest;use serde::Deserialize;

#[derive(Debug, Deserialize)]struct Post {    userId: u32,    id: u32,    title: String,    body: String,}

#[tokio::main]async fn main() -> Result<(), reqwest::Error> {    let url = "https://jsonplaceholder.typicode.com/posts/1";    let response = reqwest::get(url).await?;        let post: Post = response.json().await?;    println!("{:#?}", post);        Ok(())}

Vamos analisar o código:

• O atributo #[derive(Debug, Deserialize)] gera automaticamente os traits para exibição e desserialização.
• #[tokio::main] transforma a função em um ponto de entrada assíncrono.
• reqwest::get() executa uma requisição GET, e .await aguarda sua conclusão.
• response.json() converte a resposta JSON em nossa estrutura.

Execute o código com o comando cargo run. Você verá os dados do post no console.

3. Requisição POST com envio de dados

Agora vamos ver como enviar dados para o servidor. Para uma requisição POST, precisaremos criar uma estrutura para os dados enviados e usar o método post():

use reqwest::Client;use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize)]struct NewPost {    title: String,    body: String,    userId: u32,}

#[derive(Debug, Deserialize)]struct CreatedPost {    id: u32,    title: String,    body: String,    userId: u32,}

#[tokio::main]async fn main() -> Result<(), reqwest::Error> {    let client = Client::new();        let new_post = NewPost {        title: "Meu primeiro post em Rust".to_string(),        body: "Este é o corpo do post enviado com reqwest".to_string(),        userId: 1,    };        let response = client        .post("https://jsonplaceholder.typicode.com/posts")        .json(&new_post)        .send()        .await?;        let created_post: CreatedPost = response.json().await?;    println!("Post criado com ID: {}", created_post.id);    println