Hogyan küldjünk SMS-t az SMPP API-n keresztül Python használatával

Az SMPP (Short Message Peer-to-Peer) API egy széles körben elterjedt protokoll SMS-üzenetek cseréjére SMS entitások, például ESME-k (External Short Message Entities) és SMSC-k (Short Message Service Centers) között. Az Ozeki SMS Gateway platform felhasználói számára az SMPP protokoll szintű interakciók megértése elengedhetetlen a teljesítmény optimalizálásához, hibakereséshez és egyéni integrációkhoz. Ez a útmutató bemutatja az SMPP PDU-kat (Protocol Data Units), amelyek szükségesek egy SMPP API kapcsolat létesítéséhez, karbantartásához és SMS-üzenetek küldéséhez, gyakorlati Python példákkal.

Hogyan küldjünk SMS-t az SMPP API-n keresztül Python használatával (Gyors lépések)

1. Ellenőrizze az SMPP hitelesítő adatokat
2. Írja meg és futtassa a Python szkriptet
3. Ellenőrizze az eredményt

Hogyan küldjünk SMS-t az SMPP API-n keresztül Python használatával (Videó útmutató)

Ebben a videóban megtanulhatja, hogyan küldhet SMS-üzeneteket Python segítségével az SMPP API-n keresztül az Ozeki SMS Gateway használatával. Az útmutató bemutatja, hogyan állíthat be egy SMPP felhasználót, hogyan csatlakozhat az smpplib könyvtár segítségével, és hogyan küldhet SMS-t néhány sornyi kóddal. Azt is megtudhatja, hogyan tarthatja életben a kapcsolatot és hogyan kezelheti a kézbesítési jelentéseket. A végére lesz egy működő Python szkriptje, amely készen áll az SMS-üzenetek SMPP-n keresztüli küldésére.

1. lépés - SMPP felhasználó kiválasztása

Az Ozeki SMS Gateway felületén lépjen a "Felhasználók és alkalmazások" részre, és válassza ki a korábban létrehozott SMPP felhasználót. Ez a felhasználó szükséges az SMPP kapcsolat létesítéséhez Pythonból.

2. lépés - Kapcsolati adatok

Az SMPP felhasználó kiválasztása után lépjen a "Súgó" fülre, ahol megtalálja a kapcsolati adatokat, például az IP címet, portszámot, felhasználónevet és jelszót. Ezeket az értékeket fogja használni a Python kódjában az SMS Gateway-hez való csatlakozáshoz.

3. lépés - A Python kód beillesztése

Nyissa meg az IDE-jét vagy Python szerkesztőjét, és illessze be az alábbi "Teljes Python SMPP API kliens példa SMS küldéséhez" SMPP kapcsolati kódot az smpplib könyvtár használatával. Ez a kód kezdeményezi a kapcsolatot és előkészíti a környezetet az SMS küldéséhez.

4. lépés - Adatok cseréje

Frissítse a helykitöltő értékeket a kódban a valós SMPP hitelesítő adatokkal (hoszt, port, felhasználónév, jelszó) és azokkal a telefonszámokkal, amelyeket az üzenetküldéshez szeretne használni.

5. lépés - Sikeres bejelentkezés

Futtassa a szkriptet. Ha minden helyesen van beállítva, az Ozeki SMS Gateway felületén a létrehozott smpp_user a naplóban megjeleníti, hogy sikeres volt. Ez megerősíti, hogy a kapcsolat él és készen áll az üzenetek küldésére.

Hogyan hozzunk létre SMPP API kapcsolatot Pythonban SMS üzenetküldéshez

Az SMS SMPP API-n keresztüli küldéséhez először Ozeki SMS Gateway SMPP szerveréhez. Íme, hogyan teheti meg Pythonban a smpplib könyvtár használatával:

import smpplib

# Kapcsolati paraméterek
HOST = 'your.ozeki.server'
PORT = 2775
SYSTEM_ID = 'your_username'
PASSWORD = 'your_password'

# Kliens létrehozása
client = smpplib.client.Client(HOST, PORT)

# Kötés feladóként
client.connect()
client.bind_transmitter(
    system_id=SYSTEM_ID,
    password=PASSWORD,
)

print("Sikeresen kötve az SMPP szerverhez")

Kulcsfontosságú PDU-k a kapcsolatfelépítéshez

Stabil SMPP API kapcsolat fenntartása Pythonban SMS küldéshez

Az SMPP kapcsolatokhoz időszakos keep-alive jelek szükségesek az időtúllépés elkerüléséhez. Íme, hogyan valósíthatja meg Pythonban:

import time
import threading

def send_enquire_link():
    while True:
        try:
            client.enquire_link()
            print("Enquire_link PDU elküldve")
        except Exception as e:
            print(f"Hiba az enquire_link küldésekor: {e}")
        time.sleep(30)  # Küldés 30 másodpercenként

# Keep-alive szál indítása
keepalive_thread = threading.Thread(target=send_enquire_link)
keepalive_thread.daemon = True
keepalive_thread.start()

SMS küldése Pythonnal az SMPP API-n keresztül

Íme egy teljes példa egy SMS küldésére és a válasz kezelésére:

def send_sms(source_addr, destination_addr, message):
    try:
        # submit_sm PDU küldése
        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 kódolás
        )
        
        print(f"Üzenet elküldve, message_id: {pdu.message_id}")
        
    except smpplib.exceptions.PDUError as e:
        print(f"PDU hiba: {e}")
    except Exception as e:
        print(f"Hiba az SMS küldésekor: {e}")

# Példa használatra
send_sms(
    source_addr="12345",
    destination_addr="+1234567890",
    message="Helló a Python SMPP kliensből!"
)

Kézbesítési jelentések kezelése

Kézbesítési jelentések fogadása Pythonban:

def handle_delivery_report(pdu):
    print(f"Kézbesítési jelentés érkezett a(z) {pdu.receipted_message_id} üzenethez")
    print(f"Állapot: {pdu.message_state}")

# Kézbesítési jelentés kezelő beállítása
client.set_message_received_handler(lambda pdu: handle_delivery_report(pdu))

Teljes Python SMPP API kliens példa SMS küldéséhez

Íme egy teljes működő példa:

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)
        
        # Kötés a szerverhez
        self.client.connect()
        self.client.bind_transceiver(
            system_id=system_id,
            password=password,
        )
        
        # Keep-alive indítása
        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"Újracsatlakozás sikertelen: {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"Küldés sikertelen: {e}")
            return None
    
    def handle_message(self, pdu):
        if pdu.command == "deliver_sm":
            print(f"Kézbesítési jelentés: {pdu.receipted_message_id} - {pdu.message_state}")
        else:
            print(f"Fogadott üzenet: {pdu.short_message}")

# Használat
if __name__ == "__main__":
    client = SMPPClient(
        host="your.ozeki.server",
        port=2775,
        system_id="your_username",
        password="your_password"
    )
    
    # Üzenet küldése
    client.send_sms(
        from_addr="12345",
        to_addr="+1234567890",
        message="Helló a teljes Python SMPP kliensből!"
    )
    
    # Folyamatos futás
    while True:
        time.sleep(1)

Összegzés

Ez az útmutató bemutatta, hogyan dolgozhat az SMPP API-val protokoll szinten Python használatával. Az Ozeki SMS Gateway segítségével e példák megvalósításával robusztus SMS alkalmazásokat építhet olyan funkciókkal, mint a kapcsolatkezelés, üzenetküldés és kézbesítési jelentések kezelése. Az smpplib könyvtár kényelmes módot biztosít az SMPP PDU-k kezelésére, miközben kezeli az alacsony szintű protokoll részleteket.

Ne felejtse el a kivételek megfelelő kezelését a termelési kódban, valamint a maximális megbízhatóság érdekében implementálja az újracsatlakozási logikát. A megadott teljes példa tartalmaz alapvető újracsatlakozási kezelést és keep-alive funkcionalitást.