Envoi de SMS en Rust : RustSMS — bibliothèque API pour travailler avec des passerelles SMS

Envoi de SMS en Rust : Aperçu de la bibliothèque RustSMS

Dans le monde moderne du développement web et de l'automatisation, l'envoi de messages SMS reste une tâche courante : de l'authentification à deux facteurs aux notifications de statut de commande. Si vous codez en Rust et recherchez un moyen fiable d'intégration avec des fournisseurs de SMS, la bibliothèque RustSMS est ce qu'il vous faut. Elle fournit une API unique, asynchrone et type-safe pour travailler avec des dizaines de passerelles SMS (Twilio, Vonage, Clickatell, SMS.ru et autres).

Dans cet article, nous allons passer en revue les fonctionnalités clés de RustSMS, montrer des exemples de code et expliquer comment commencer à envoyer des messages en quelques minutes.

Fonctionnalités principales de RustSMS

• Interface unique — quel que soit le fournisseur choisi, vous utilisez le même ensemble de méthodes.
• Asynchrone — la bibliothèque est construite sur tokio et reqwest, ce qui permet de ne pas bloquer le thread principal.
• Prise en charge des passerelles populaires — Twilio, Vonage (Nexmo), Clickatell, SMS.ru, MessageBird et autres.
• Configurations type-safe — tous les paramètres (numéro, texte, fournisseur) sont vérifiés à la compilation.
• Extension facile — vous pouvez écrire votre propre adaptateur pour n'importe quelle passerelle personnalisée.

Installation

Ajoutez la dépendance à votre Cargo.toml :

[dependencies]rustsms = "0.5"tokio = { version = "1", features = ["full"] }

Exemple de base d'envoi de SMS

Avant d'envoyer, vous devez créer une configuration pour le fournisseur choisi. Voici un exemple avec Twilio :

use rustsms::{SmsClient, providers::twilio::TwilioConfig};use std::error::Error;

#[tokio::main]async fn main() -> Result<(), Box> {    // Création de la configuration pour Twilio    let config = TwilioConfig::new(        "YOUR_ACCOUNT_SID",        "YOUR_AUTH_TOKEN",        "+1234567890", // votre numéro d'expéditeur    );

    // Initialisation du client    let client = SmsClient::new(config);

    // Envoi du message    let response = client        .send("+0987654321", "Bonjour depuis Rust !")        .await?;

    println!("SMS envoyé ! ID : {}", response.message_id);    Ok(())}

Travailler avec plusieurs fournisseurs

RustSMS permet de basculer facilement entre les fournisseurs. Il suffit de modifier la configuration :

use rustsms::{SmsClient, providers::vonage::VonageConfig};

let config = VonageConfig::new(    "YOUR_API_KEY",    "YOUR_API_SECRET",    "RustSMS",);let client = SmsClient::new(config);

Gestion des erreurs et des statuts

La bibliothèque renvoie des erreurs détaillées si quelque chose ne va pas. Vous pouvez les traiter à l'aide du pattern matching :

match client.send("+1111111111", "Test").await {    Ok(response) => println!("Succès : {:?}", response),    Err(e) => match e {        rustsms::Error::Api { code, message } => {            eprintln!("Erreur API {} : {}", code, message);        }        rustsms::Error::Network(e) => {            eprintln!("Erreur réseau : {}", e);        }        _ => eprintln!("Erreur inconnue"),    },}

Fonctionnalités avancées : modèles et en-têtes personnalisés

RustSMS prend en charge l'envoi de messages à l'aide de modèles (par exemple, pour les codes OTP) et d'en-têtes HTTP personnalisés. Exemple avec un modèle :

let otp_code = 123456;let message = format!("Votre code de confirmation : {}", otp_code);client    .send("+1111111111", &message)    .await?;

Pour des scénarios plus complexes (par exemple, l'envoi via une passerelle SMS avec des paramètres supplémentaires), vous pouvez utiliser la méthode send_with_opts :

use rustsms::options::SendOptions;

let opts = SendOptions::new()    .with_callba