Wie man SMS über die SMPP-API mit Python versendet

Die Short Message Peer-to-Peer (SMPP)-API ist ein weit verbreitetes Protokoll zum Austausch von SMS-Nachrichten zwischen SMS-Entitäten wie ESMEs (External Short Message Entities) und SMSCs (Short Message Service Centers). Für Benutzer der Ozeki SMS Gateway-Plattform ist das Verständnis der SMPP-Protokollebene entscheidend für die Optimierung der Leistung, Fehlerbehebung und benutzerdefinierte Integrationen. Diese Anleitung erklärt die SMPP PDUs (Protocol Data Units), die erforderlich sind, um eine SMPP-API-Verbindung aufzubauen, aufrechtzuerhalten und zum Senden von SMS-Nachrichten zu nutzen, mit praktischen Python-Beispielen.

Abbildung 1 - SMS mit Python über die SMPP-API versenden

Wie man SMS über die SMPP-API mit Python versendet (Schnelle Schritte)

Überprüfen Sie die SMPP-Zugangsdaten
Schreiben und führen Sie das Python-Skript aus
Überprüfen Sie das Ergebnis

Wie man SMS über die SMPP-API mit Python versendet (Video-Tutorial)

In diesem Video lernen Sie, wie Sie SMS-Nachrichten mit Python über die SMPP-API mit Ozeki SMS Gateway versenden. Das Tutorial zeigt, wie Sie einen SMPP-Benutzer einrichten, eine Verbindung mit der smpplib-Bibliothek herstellen und eine SMS mit wenigen Codezeilen versenden. Sie werden auch sehen, wie Sie die Verbindung aufrechterhalten und Zustellberichte verarbeiten. Am Ende haben Sie ein funktionierendes Python-Skript, das bereit ist, SMS-Nachrichten über SMPP zu versenden.

Schritt 1 - SMPP-Benutzer auswählen

In der Ozeki SMS Gateway-Oberfläche gehen Sie zum Abschnitt "Benutzer und Anwendungen" und wählen den zuvor erstellten SMPP-Benutzer aus. Dieser Benutzer ist erforderlich, um die SMPP-Verbindung von Python aus herzustellen.

Schritt 2 - Verbindungsdetails

Nachdem Sie den SMPP-Benutzer ausgewählt haben, gehen Sie zum "Hilfe"-Tab und Sie sehen Verbindungsdetails wie IP-Adresse, Portnummer, Benutzername und Passwort. Diese Werte werden in Ihrem Python-Code verwendet, um eine Verbindung zum SMS Gateway herzustellen.

Schritt 3 - Python-Code einfügen

Öffnen Sie Ihre IDE oder Ihren Python-Editor und fügen Sie den "Vollständigen Python-SMPP-API-Client-Beispielcode zum Senden von SMS" von unten ein, der die smpplib-Bibliothek verwendet. Dieser Code initiiert die Verbindung und bereitet die Umgebung für das Versenden von SMS vor.

Schritt 4 - Daten ersetzen

Aktualisieren Sie die Platzhalterwerte im Code mit Ihren tatsächlichen SMPP-Zugangsdaten (Host, Port, Benutzername, Passwort) und den Telefonnummern, die Sie zum Versenden von Nachrichten verwenden möchten.

Schritt 5 - Erfolgreich

Führen Sie das Skript aus. Wenn alles korrekt eingerichtet ist, zeigt der erstellte smpp_user in der Ozeki SMS Gateway-Oberfläche im Log an, dass es erfolgreich war. Dies bestätigt, dass die Verbindung aktiv und bereit zum Versenden von Nachrichten ist.

Wie man eine SMPP-API-Verbindung in Python für SMS-Nachrichten einrichtet

Um SMS über die SMPP-API zu versenden, müssen Sie zuerst SMPP-Server von Ozeki SMS Gateway binden. So geht es in Python mit der smpplib-Bibliothek:

import smpplib

# Verbindungsparameter
HOST = 'your.ozeki.server'
PORT = 2775
SYSTEM_ID = 'your_username'
PASSWORD = 'your_password'

# Client erstellen
client = smpplib.client.Client(HOST, PORT)

# Als Transmitter binden
client.connect()
client.bind_transmitter(
    system_id=SYSTEM_ID,
    password=PASSWORD,
)

print("Erfolgreich an den SMPP-Server gebunden")

Wichtige PDUs für die Verbindungseinrichtung

PDU	Python-Methode	Zweck
`bind_transmitter`	`client.bind_transmitter()`	Initiiert eine Verbindung zum Versenden von SMS
`bind_receiver`	`client.bind_receiver()`	Richtet eine Verbindung zum Empfangen von SMS ein
`bind_transceiver`	`client.bind_transceiver()`	Ermöglicht bidirektionale Nachrichtenübermittlung

Aufrechterhaltung einer stabilen SMPP-API-Verbindung in Python für den SMS-Versand

SMPP-Verbindungen erfordern periodische Keep-Alive-Signale, um Timeouts zu vermeiden. So implementieren Sie es in Python:

import time
import threading

def send_enquire_link():
    while True:
        try:
            client.enquire_link()
            print("enquire_link PDU gesendet")
        except Exception as e:
            print(f"Fehler beim Senden von enquire_link: {e}")
        time.sleep(30)  # Alle 30 Sekunden senden

# Keep-Alive-Thread starten
keepalive_thread = threading.Thread(target=send_enquire_link)
keepalive_thread.daemon = True
keepalive_thread.start()

SMS-Versand mit Python über die SMPP-API

Hier ist ein vollständiges Beispiel für das Senden einer SMS und die Behandlung der Antwort:

def send_sms(source_addr, destination_addr, message):
    try:
        # Send submit_sm PDU
        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,  # GSM 7-bit Kodierung
        )
        
        print(f"Nachricht übermittelt, message_id: {pdu.message_id}")
        
    except smpplib.exceptions.PDUError as e:
        print(f"PDU-Fehler: {e}")
    except Exception as e:
        print(f"Fehler beim Senden der SMS: {e}")

# Beispielaufruf
send_sms(
    source_addr="12345",
    destination_addr="+1234567890",
    message="Hallo vom Python SMPP-Client!"
)

Umgang mit Zustellberichten

So empfangen Sie Zustellberichte in Python:

def handle_delivery_report(pdu):
    print(f"Zustellbericht für Nachricht {pdu.receipted_message_id} erhalten")
    print(f"Status: {pdu.message_state}")

# Zustellbericht-Handler einrichten
client.set_message_received_handler(lambda pdu: handle_delivery_report(pdu))

Vollständiges Python SMPP-API-Client-Beispiel für den SMS-Versand

Hier ist ein vollständiges funktionierendes Beispiel:

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)
        
        # Mit Server verbinden
        self.client.connect()
        self.client.bind_transceiver(
            system_id=system_id,
            password=password,
        )
        
        # Keep-Alive starten
        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"Wiederverbindung fehlgeschlagen: {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"Sendevorgang fehlgeschlagen: {e}")
            return None
    
    def handle_message(self, pdu):
        if pdu.command == "deliver_sm":
            print(f"Zustellbericht: {pdu.receipted_message_id} - {pdu.message_state}")
        else:
            print(f"Nachricht erhalten: {pdu.short_message}")

# Verwendung
if __name__ == "__main__":
    client = SMPPClient(
        host="your.ozeki.server",
        port=2775,
        system_id="your_username",
        password="your_password"
    )
    
    # Nachricht senden
    client.send_sms(
        from_addr="12345",
        to_addr="+1234567890",
        message="Hallo vom vollständigen Python SMPP-Client!"
    )
    
    # Laufend halten
    while True:
        time.sleep(1)

Fazit

Diese Anleitung hat Ihnen gezeigt, wie Sie mit der SMPP-API auf Protokollebene mit Python arbeiten können. Durch die Implementierung dieser Beispiele mit Ozeki SMS Gateway können Sie robuste SMS-Anwendungen mit Funktionen wie Verbindungsverwaltung, Nachrichtenversand und Behandlung von Zustellberichten erstellen. Die Bibliothek smpplib bietet eine bequeme Möglichkeit, mit SMPP-PDUs zu arbeiten, während sie die Details des Low-Level-Protokolls für Sie handhabt.

Denken Sie daran, Ausnahmen im Produktionscode ordnungsgemäß zu behandeln und eine Wiederherstellungslogik für maximale Zuverlässigkeit zu implementieren. Das vollständige Beispiel enthält grundlegende Wiederherstellungsbehandlung und Keep-Alive-Funktionalität.