Como processar consultas de CPF de forma assíncrona em Rust com Tokio

// Cargo.toml
[dependencies]
tokio = { version = "1", features = ["full"] }
reqwest = { version = "0.12", features = ["json"] }
serde = { version = "1.0", features = ["derive"] }
futures = "0.3"

use reqwest::header::{HeaderMap, HeaderValue};
use serde::Deserialize;
use std::sync::Arc;

#[derive(Debug, Deserialize)]
pub struct CpfResponse {
    pub success: bool,
    pub data: CpfData,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CpfData {
    pub cpf: String,
    pub name: String,
    pub name_upper: String,
    pub gender: String,
    pub birth_date: String,
    pub day: String,
    pub month: String,
    pub year: String,
}

pub struct CpfClient {
    client: reqwest::Client,
    api_key: String,
}

impl CpfClient {
    pub fn new(api_key: String) -> Arc<Self> {
    let client = reqwest::Client::builder()
    .pool_max_idle_per_host(20)
    .timeout(std::time::Duration::from_secs(10))
    .build()
    .expect("Falha ao criar cliente HTTP");

    Arc::new(Self { client, api_key })
    }

    pub async fn consultar(&self, cpf: &str) -> Result<CpfResponse, String> {
    let mut headers = HeaderMap::new();
    headers.insert(
    "x-api-key",
    HeaderValue::from_str(&self.api_key).map_err(|e| e.to_string())?,
    );

    let url = format!("https://api.cpfhub.io/cpf/{}", cpf);

    let response = self.client
    .get(&url)
    .headers(headers)
    .send()
    .await
    .map_err(|e| format!("Erro na requisição: {}", e))?;

    response.json::<CpfResponse>()
    .await
    .map_err(|e| format!("Erro ao desserializar: {}", e))
    }
}

use futures::future::join_all;

async fn processar_lote(
    client: &Arc<CpfClient>,
    cpfs: Vec<String>,
) -> Vec<(String, Result<CpfResponse, String>)> {
    let futures: Vec<_> = cpfs.into_iter().map(|cpf| {
    let client = Arc::clone(client);
    async move {
    let resultado = client.consultar(&cpf).await;
    (cpf, resultado)
    }
    }).collect();

    join_all(futures).await
}

use tokio::sync::Semaphore;

async fn processar_com_limite(
    client: &Arc<CpfClient>,
    cpfs: Vec<String>,
    max_concurrent: usize,
) -> Vec<(String, Result<CpfResponse, String>)> {
    let semaphore = Arc::new(Semaphore::new(max_concurrent));
    let mut handles = Vec::new();

    for cpf in cpfs {
    let client = Arc::clone(client);
    let semaphore = Arc::clone(&semaphore);

    let handle = tokio::spawn(async move {
    let _permit = semaphore.acquire().await
    .expect("Semáforo fechado");

    let resultado = client.consultar(&cpf).await;
    (cpf, resultado)
    });

    handles.push(handle);
    }

    let mut resultados = Vec::new();
    for handle in handles {
    if let Ok(resultado) = handle.await {
    resultados.push(resultado);
    }
    }

    resultados
}

#[tokio::main]
async fn main() {
    let api_key = std::env::var("CPFHUB_API_KEY")
    .expect("Defina CPFHUB_API_KEY");

    let client = CpfClient::new(api_key);

    let cpfs: Vec<String> = vec![
    "12345678900", "98765432100", "11122233344",
    "55566677788", "99988877766",
    ].into_iter().map(String::from).collect();

    let total = cpfs.len();
    println!("Processando {} CPFs com limite de 3 simultâneos...", total);

    let inicio = std::time::Instant::now();
    let resultados = processar_com_limite(&client, cpfs, 3).await;
    let duracao = inicio.elapsed();

    let mut sucessos = 0;
    let mut falhas = 0;

    for (cpf, resultado) in &resultados {
    match resultado {
    Ok(r) if r.success => {
    println!("[OK] {} -> {}", cpf, r.data.name);
    sucessos += 1;
    }
    Ok(_) => {
    println!("[--] {} -> Não encontrado", cpf);
    falhas += 1;
    }
    Err(e) => {
    println!("[ER] {} -> {}", cpf, e);
    falhas += 1;
    }
    }
    }

    println!("\nRelatório:");
    println!(" Total: {}", total);
    println!(" Sucessos: {}", sucessos);
    println!(" Falhas: {}", falhas);
    println!(" Tempo: {:.2?}", duracao);
}