Envoi de SMS en Rust : aperçu des bibliothèques API

Envoi de SMS en Rust : Aperçu des API et bibliothèques

Rust est un langage de programmation système moderne qui combine haute performance et sécurité mémoire. Bien que l'écosystème Rust soit plus jeune que celui de Python ou JavaScript, il dispose déjà de tous les outils nécessaires pour l'intégration avec les services SMS. Dans cet article, nous verrons comment envoyer des messages SMS depuis des applications Rust en utilisant des API et bibliothèques populaires.

Approches principales pour l'envoi de SMS

Il existe deux méthodes principales pour envoyer des SMS depuis Rust :

• Utilisation d'un client HTTP — appel direct à l'API REST du fournisseur SMS (Twilio, Vonage, SMS-Center, etc.)
• Utilisation de crates spécialisés — bibliothèques prêtes à l'emploi qui encapsulent l'API du fournisseur dans une interface Rust pratique

Option 1 : Envoi de SMS via l'API Twilio

Twilio est l'un des services les plus populaires pour l'envoi de SMS. Pour travailler avec lui, vous aurez besoin de reqwest (client HTTP) et serde (sérialisation/désérialisation 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"; // Numéro acheté chez 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: "Bonjour depuis 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 envoyé ! SID : {}, Statut : {}", sms_response.sid, sms_response.status);

    Ok(())}

Option 2 : Utilisation du crate twilio

Pour une utilisation plus pratique de Twilio, il existe un crate spécialisé twilio. Il fournit une API typée et gère automatiquement l'authentification.

// 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!("Message envoyé ! SID : {}", message.sid);    Ok(())}

Option 3 : Envoi de SMS via Vonage (Nexmo)

Vonage (anciennement Nexmo) est un autre fournisseur populaire. Pour travailler avec lui, vous pouvez utiliser le 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", "Bonjour depuis Rust!")