Cliente HTTP para Rust: mejores bibliotecas

Cliente HTTP para Rust: resumen de las mejores bibliotecas

Rust es un lenguaje de programación de sistemas que ha ganado popularidad gracias a su seguridad, rendimiento y ausencia de recolector de basura. Al desarrollar aplicaciones web, microservicios o herramientas para trabajar con API, a menudo surge la necesidad de enviar solicitudes HTTP. En este artículo, revisaremos las mejores bibliotecas para trabajar con HTTP en Rust, sus características, rendimiento y ejemplos de uso.

1. reqwest — el cliente HTTP más popular

reqwest es un cliente HTTP de alto nivel y fácil de usar para Rust, construido sobre hyper. Soporta tanto solicitudes síncronas como asíncronas, procesamiento automático de JSON, cookies, proxy y TLS.

Características principales:

Soporte para async/await (requiere tokio o async-std)
Serialización/deserialización automática de JSON (a través de serde)
Trabajo con formularios, multipart, archivos
Gestión de cookies y sesiones
Soporte para HTTP/2 y TLS (a través de native-tls o rustls)

Ejemplo de solicitud GET con reqwest:

use reqwest;

#[tokio::main]async fn main() -> Result<(), reqwest::Error> {    let response = reqwest::get("https://api.github.com/repos/rust-lang/rust")        .await?;

    let body = response.text().await?;    println!("Respuesta: {}", body);    Ok(())}

Ejemplo de solicitud POST con JSON:

use reqwest;use serde_json::json;

#[tokio::main]async fn main() -> Result<(), reqwest::Error> {    let client = reqwest::Client::new();    let payload = json!({"title": "Nueva tarea", "completed": false});

    let response = client        .post("https://jsonplaceholder.typicode.com/todos")        .json(&payload)        .send()        .await?;

    println!("Estado: {}", response.status());    Ok(())}

2. ureq — minimalista y rápido

ureq es un cliente HTTP síncrono ligero sin dependencias de runtime async. Es ideal para scripts, utilidades CLI y proyectos donde no se necesita asincronía.

Características:

API puramente síncrona
Cantidad mínima de dependencias
Soporte para JSON, multipart, cookies
Soporte integrado para TLS (a través de native-tls o rustls)

Ejemplo con ureq:

use ureq;

fn main() -> Result<(), ureq::Error> {    let response = ureq::get("https://httpbin.org/get")        .set("Accept", "application/json")        .call()?;

    let body: serde_json::Value = response.into_json()?;    println!("JSON: {}", body);    Ok(())}

3. hyper — base de bajo nivel

hyper es una biblioteca HTTP asíncrona sobre la que se construyen muchos otros clientes (incluyendo reqwest). Ofrece control total sobre las solicitudes, pero requiere más código y comprensión de conceptos asíncronos.

Cuándo elegir hyper:

Se necesita el máximo rendimiento
Se requiere un ajuste fino de las conexiones
Estás construyendo tu propio servidor HTTP o proxy

Ejemplo de solicitud GET simple con hyper:

use hyper::{Client, Uri};use hyper::body::HttpBody;

#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let client = Client::new();    let uri: Uri = "http://httpbin.org/ip".parse()?;    let mut response = client.get(uri).await?;

    while let Some(chunk) = response.body_mut().data().await {        let data = chunk?;        println!("{}", String::from_utf8_lossy(&data));    }    Ok(())}