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.
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.