Comment envoyer des SMS via l'API SMPP en utilisant Python

L'API Short Message Peer-to-Peer (SMPP) est un protocole largement adopté pour échanger des messages SMS entre des entités SMS comme les ESME (External Short Message Entities) et les SMSC (Short Message Service Centers). Pour les utilisateurs de la plateforme Ozeki SMS Gateway, comprendre les interactions au niveau du protocole SMPP est essentiel pour optimiser les performances, déboguer et réaliser des intégrations personnalisées. Ce guide explique les PDU (Unités de Données de Protocole) SMPP nécessaires pour établir, maintenir et utiliser une connexion API SMPP afin d'envoyer des messages SMS, avec des exemples pratiques en Python.

Comment envoyer des SMS via l'API SMPP en utilisant Python (étapes rapides)

1. Vérifier les identifiants SMPP
2. Écrire et exécuter le script Python
3. Vérifier le résultat

Comment envoyer des SMS via l'API SMPP en utilisant Python (tutoriel vidéo)

Dans cette vidéo, vous apprendrez à envoyer des messages SMS en utilisant Python via l'API SMPP avec Ozeki SMS Gateway. Le tutoriel montre comment configurer un utilisateur SMPP, se connecter en utilisant la bibliothèque smpplib et envoyer un SMS avec quelques lignes de code. Vous verrez également comment maintenir la connexion active et gérer les rapports de livraison. À la fin, vous aurez un script Python fonctionnel prêt à envoyer des messages SMS via SMPP.

Étape 1 - Sélectionner l'utilisateur SMPP

Dans l'interface Ozeki SMS Gateway, allez dans la section "Utilisateurs et applications" et sélectionnez l'utilisateur SMPP précédemment créé. Cet utilisateur est nécessaire pour établir la connexion SMPP depuis Python.

Étape 2 - Détails de la connexion

Après avoir sélectionné l'utilisateur SMPP, allez dans l'onglet "Aide" et vous verrez les détails de connexion tels que l'adresse IP, le numéro de port, le nom d'utilisateur et le mot de passe. Ces valeurs seront utilisées dans votre code Python pour vous connecter à la passerelle SMS.

Étape 3 - Coller le code Python

Ouvrez votre IDE ou éditeur Python et collez le code de connexion SMPP "Exemple complet de client Python API SMPP pour l'envoi de SMS" ci-dessous en utilisant la bibliothèque smpplib. Ce code initie la connexion et prépare l'environnement pour l'envoi de SMS.

Étape 4 - Remplacer les données

Mettez à jour les valeurs fictives dans le code avec vos identifiants SMPP réels (hôte, port, nom d'utilisateur, mot de passe) et les numéros de téléphone que vous souhaitez utiliser pour envoyer des messages.

Étape 5 - Succès

Exécutez le script. Si tout est configuré correctement, dans l'interface Ozeki SMS Gateway, l'utilisateur smpp_user créé affichera dans le journal que la connexion a réussi. Cela confirme que la connexion est active et prête à envoyer des messages.

Comment établir une connexion API SMPP en Python pour l'envoi de SMS

Pour envoyer des SMS via l'API SMPP, vous devez d'abord serveur SMPP d'Ozeki SMS Gateway. Voici comment faire en Python en utilisant la bibliothèque smpplib :

import smpplib

# Paramètres de connexion
HOST = 'votre.serveur.ozeki'
PORT = 2775
SYSTEM_ID = 'votre_nom_utilisateur'
PASSWORD = 'votre_mot_de_passe'

# Créer un client
client = smpplib.client.Client(HOST, PORT)

# Lier en tant qu'émetteur
client.connect()
client.bind_transmitter(
    system_id=SYSTEM_ID,
    password=PASSWORD,
)

print("Connexion au serveur SMPP établie avec succès")

PDU clés pour la configuration de la connexion

Maintenir une connexion API SMPP stable en Python pour l'envoi de SMS

Les connexions SMPP nécessitent des signaux de maintien périodiques pour éviter les déconnexions. Voici comment implémenter cela en Python :

import time
import threading

def send_enquire_link():
    while True:
        try:
            client.enquire_link()
            print("PDU enquire_link envoyé")
        except Exception as e:
            print(f"Erreur lors de l'envoi de enquire_link : {e}")
        time.sleep(30)  # Envoyer toutes les 30 secondes

# Démarrer le thread de maintien
keepalive_thread = threading.Thread(target=send_enquire_link)
keepalive_thread.daemon = True
keepalive_thread.start()

Envoyer des SMS avec Python via l'API SMPP

Voici un exemple complet d'envoi d'un SMS et de gestion de la réponse :

def send_sms(source_addr, destination_addr, message):
    try:
        # Envoyer la PDU submit_sm
        pdu = client.send_message(
            source_addr_ton=smpplib.consts.SMPP_TON_INTL,
            source_addr_npi=smpplib.consts.SMPP_NPI_ISDN,
            source_addr=source_addr,
            dest_addr_ton=smpplib.consts.SMPP_TON_INTL,
            dest_addr_npi=smpplib.consts.SMPP_NPI_ISDN,
            destination_addr=destination_addr,
            short_message=message,
            data_coding=0x00,  # Encodage GSM 7 bits
        )
        
        print(f"Message soumis, ID du message : {pdu.message_id}")
        
    except smpplib.exceptions.PDUError as e:
        print(f"Erreur PDU : {e}")
    except Exception as e:
        print(f"Erreur lors de l'envoi du SMS : {e}")

# Exemple d'utilisation
send_sms(
    source_addr="12345",
    destination_addr="+1234567890",
    message="Bonjour depuis le client SMPP Python !"
)

Gérer les rapports de livraison

Pour recevoir des rapports de livraison en Python :

def handle_delivery_report(pdu):
    print(f"Rapport de livraison reçu pour le message {pdu.receipted_message_id}")
    print(f"Statut : {pdu.message_state}")

# Configurer le gestionnaire de rapports de livraison
client.set_message_received_handler(lambda pdu: handle_delivery_report(pdu))

Exemple complet de client Python API SMPP pour l'envoi de SMS

Voici un exemple complet fonctionnel :

import smpplib
import threading
import time

class SMPPClient:
    def __init__(self, host, port, system_id, password):
        self.client = smpplib.client.Client(host, port)
        self.client.set_message_received_handler(self.handle_message)
        
        # Se lier au serveur
        self.client.connect()
        self.client.bind_transceiver(
            system_id=system_id,
            password=password,
        )
        
        # Démarrer le maintien
        self.start_keepalive()
    
    def start_keepalive(self):
        def _keepalive():
            while True:
                try:
                    self.client.enquire_link()
                except Exception:
                    try:
                        self.client.connect()
                        self.client.bind_transceiver(
                            system_id=SYSTEM_ID,
                            password=PASSWORD,
                        )
                    except Exception as e:
                        print(f"Échec de la reconnexion : {e}")
                time.sleep(30)
        
        thread = threading.Thread(target=_keepalive)
        thread.daemon = True
        thread.start()
    
    def send_sms(self, from_addr, to_addr, message):
        try:
            return self.client.send_message(
                source_addr=from_addr,
                destination_addr=to_addr,
                short_message=message,
            )
        except Exception as e:
            print(f"Échec de l'envoi : {e}")
            return None
    
    def handle_message(self, pdu):
        if pdu.command == "deliver_sm":
            print(f"Rapport de livraison : {pdu.receipted_message_id} - {pdu.message_state}")
        else:
            print(f"Message reçu : {pdu.short_message}")

# Utilisation
if __name__ == "__main__":
    client = SMPPClient(
        host="votre.serveur.ozeki",
        port=2775,
        system_id="votre_nom_utilisateur",
        password="votre_mot_de_passe"
    )
    
    # Envoyer un message
    client.send_sms(
        from_addr="12345",
        to_addr="+1234567890",
        message="Bonjour depuis le client SMPP Python complet !"
    )
    
    # Maintenir en cours d'exécution
    while True:
        time.sleep(1)

Conclusion

Ce guide vous a montré comment travailler avec l'API SMPP au niveau du protocole en utilisant Python. En implémentant ces exemples avec Ozeki SMS Gateway, vous pouvez créer des applications SMS robustes avec des fonctionnalités comme la gestion des connexions, l'envoi de messages et la gestion des rapports de livraison. La bibliothèque smpplib offre un moyen pratique de travailler avec les PDU SMPP tout en gérant les détails de bas niveau du protocole pour vous.

N'oubliez pas de gérer correctement les exceptions dans le code de production et d'implémenter une logique de reconnexion pour une fiabilité maximale. L'exemple complet fourni inclut une gestion de base de la reconnexion et une fonctionnalité de maintien.