Envio de SMS em Rust: visão geral das bibliotecas de API

Envio de SMS em Rust: Visão geral de API e bibliotecas

Rust é uma linguagem de programação de sistemas moderna que combina alta performance e segurança de memória. Embora o ecossistema Rust seja mais jovem que o do Python ou JavaScript, ele já possui todas as ferramentas necessárias para integração com serviços de SMS. Neste artigo, veremos como enviar mensagens SMS a partir de aplicações Rust usando APIs e bibliotecas populares.

Abordagens principais para envio de SMS

Existem duas formas principais de enviar SMS a partir do Rust:

• Uso de um cliente HTTP — chamada direta à API REST do provedor de SMS (Twilio, Vonage, SMS-Center, etc.)
• Uso de crates especializados — bibliotecas prontas que encapsulam a API do provedor em uma interface Rust conveniente

Opção 1: Envio de SMS via API do Twilio

Twilio é um dos serviços mais populares para envio de SMS. Para trabalhar com ele, você precisará de reqwest (cliente HTTP) e serde (serialização/desserialização JSON).

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

// main.rsuse reqwest::Client;use serde::{Deserialize, Serialize};

#[derive(Serialize)]struct TwilioSmsRequest {    To: String,    From: String,    Body: String,}

#[derive(Deserialize, Debug)]struct TwilioSmsResponse {    sid: String,    status: String,}

#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let account_sid = "YOUR_TWILIO_ACCOUNT_SID";    let auth_token = "YOUR_TWILIO_AUTH_TOKEN";    let from_number = "+1234567890"; // Número comprado no Twilio    let to_number = "+0987654321";

    let client = Client::new();    let url = format!("https://api.twilio.com/2010-04-01/Accounts/{}/Messages.json", account_sid);

    let request_body = TwilioSmsRequest {        To: to_number.to_string(),        From: from_number.to_string(),        Body: "Olá do Rust!".to_string(),    };

    let response = client        .post(&url)        .basic_auth(account_sid, Some(auth_token))        .form(&request_body)        .send()        .await?;

    let sms_response: TwilioSmsResponse = response.json().await?;    println!("SMS enviado! SID: {}, Status: {}", sms_response.sid, sms_response.status);

    Ok(())}

Opção 2: Uso do crate twilio

Para trabalhar com o Twilio de forma mais conveniente, existe o crate especializado twilio. Ele fornece uma API tipada e lida automaticamente com a autenticação.

// Cargo.toml[dependencies]twilio = "0.5"tokio = { version = "1", features = ["full"] }

// main.rsuse twilio::Client;

#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let client = Client::new(        "YOUR_TWILIO_ACCOUNT_SID",        "YOUR_TWILIO_AUTH_TOKEN"    );

    let message = client        .send_message("+1234567890", "+0987654321", "Hello from Rust!")        .await?;

    println!("Mensagem enviada! SID: {}", message.sid);    Ok(())}

Opção 3: Envio de SMS via Vonage (Nexmo)

Vonage (anteriormente Nexmo) é outro provedor popular. Para trabalhar com ele, você pode usar o crate vonage.

// Cargo.toml[dependencies]vonage = "0.2"tokio = { version = "1", features = ["full"] }

// main.rsuse vonage::VonageClient;

#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let client = VonageClient::new(        "YOUR_VONAGE_API_KEY",        "YOUR_VONAGE_API_SECRET"    );

    let response = client        .send_sms("VonageAPI", "79001234567", "Olá do Rust!")