Jak wysłać SMS przez interfejs SMPP API za pomocą Pythona

Interfejs SMPP (Short Message Peer-to-Peer) to szeroko stosowany protokół wymiany wiadomości SMS między podmiotami SMS, takimi jak ESME (External Short Message Entities) i SMSC (Short Message Service Centers). Dla użytkowników platformy Ozeki SMS Gateway zrozumienie interakcji na poziomie protokołu SMPP jest kluczowe dla optymalizacji wydajności, debugowania i niestandardowych integracji. Ten przewodnik wyjaśnia PDU (Protocol Data Units) SMPP wymagane do nawiązania, utrzymania i wykorzystania połączenia SMPP API w celu wysyłania wiadomości SMS, z praktycznymi przykładami w Pythonie.

Jak wysłać SMS przez interfejs SMPP API za pomocą Pythona (Szybkie kroki)

1. Sprawdź dane uwierzytelniające SMPP
2. Napisz i uruchom skrypt w Pythonie
3. Zweryfikuj wynik

Jak wysłać SMS przez interfejs SMPP API za pomocą Pythona (Samouczek wideo)

W tym filmie dowiesz się, jak wysyłać wiadomości SMS za pomocą Pythona przez interfejs SMPP API z Ozeki SMS Gateway. Samouczek pokazuje, jak skonfigurować użytkownika SMPP, połączyć się za pomocą biblioteki smpplib i wysłać SMS za pomocą kilku linii kodu. Zobaczysz również, jak utrzymać połączenie przy życiu i obsługiwać raporty dostarczenia. Na końcu będziesz mieć działający skrypt w Pythonie gotowy do wysyłania wiadomości SMS przez SMPP.

Krok 1 - Wybierz użytkownika SMPP

W interfejsie Ozeki SMS Gateway przejdź do sekcji "Użytkownicy i aplikacje" i wybierz wcześniej utworzonego użytkownika SMPP. Ten użytkownik jest wymagany do nawiązania połączenia SMPP z Pythona.

Krok 2 - Dane połączenia

Po wybraniu użytkownika SMPP przejdź do zakładki "Pomoc", gdzie zobaczysz dane połączenia, takie jak adres IP, numer portu, nazwa użytkownika i hasło. Te wartości zostaną użyte w Twoim kodzie Pythona do połączenia z SMS Gateway.

Krok 3 - Wklej kod Pythona

Otwórz swoje IDE lub edytor Pythona i wklej "Kompletny przykład klienta SMPP API w Pythonie do wysyłania SMS" kod połączenia SMPP z biblioteki smpplib. Ten kod inicjuje połączenie i przygotowuje środowisko do wysyłania SMS.

Krok 4 - Zastąp dane

Zaktualizuj wartości zastępcze w kodzie swoimi rzeczywistymi danymi uwierzytelniającymi SMPP (host, port, nazwa użytkownika, hasło) oraz numerami telefonów, których chcesz użyć do wysyłania wiadomości.

Krok 5 - Sukces

Uruchom skrypt. Jeśli wszystko jest poprawnie skonfigurowane, w interfejsie Ozeki SMS Gateway w logach zostanie wyświetlona informacja, że operacja zakończyła się sukcesem, co potwierdzi, że połączenie jest aktywne i gotowe do wysyłania wiadomości.

Jak nawiązać połączenie SMPP API w Pythonie do wysyłania wiadomości SMS

Aby wysłać SMS przez SMPP API, musisz najpierw serwerem SMPP Ozeki SMS Gateway. Oto jak to zrobić w Pythonie za pomocą biblioteki smpplib:

import smpplib

# Parametry połączenia
HOST = 'your.ozeki.server'
PORT = 2775
SYSTEM_ID = 'your_username'
PASSWORD = 'your_password'

# Utwórz klienta
client = smpplib.client.Client(HOST, PORT)

# Powiąż jako nadajnik
client.connect()
client.bind_transmitter(
    system_id=SYSTEM_ID,
    password=PASSWORD,
)

print("Pomyślnie powiązano z serwerem SMPP")

Kluczowe PDU do konfiguracji połączenia

Utrzymanie stabilnego połączenia SMPP API w Pythonie do wysyłania SMS

Połączenia SMPP wymagają okresowych sygnałów keep-alive, aby zapobiec przekroczeniu czasu. Oto jak to zaimplementować w Pythonie:

import time
import threading

def send_enquire_link():
    while True:
        try:
            client.enquire_link()
            print("Wysłano PDU enquire_link")
        except Exception as e:
            print(f"Błąd podczas wysyłania enquire_link: {e}")
        time.sleep(30)  # Wysyłaj co 30 sekund

# Uruchom wątek keep-alive
keepalive_thread = threading.Thread(target=send_enquire_link)
keepalive_thread.daemon = True
keepalive_thread.start()

Oto kompletny przykład wysyłania SMS-a i obsługi odpowiedzi:

def send_sms(source_addr, destination_addr, message):
    try:
        # Wyślij 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,  # Kodowanie GSM 7-bitowe
        )
        
        print(f"Wiadomość wysłana, identyfikator: {pdu.message_id}")
        
    except smpplib.exceptions.PDUError as e:
        print(f"Błąd PDU: {e}")
    except Exception as e:
        print(f"Błąd podczas wysyłania SMS-a: {e}")

# Przykład użycia
send_sms(
    source_addr="12345",
    destination_addr="+1234567890",
    message="Witaj z klienta SMPP w Pythonie!"
)

Obsługa raportów doręczeń

Aby odbierać raporty doręczeń w Pythonie:

def handle_delivery_report(pdu):
    print(f"Otrzymano raport doręczenia dla wiadomości {pdu.receipted_message_id}")
    print(f"Status: {pdu.message_state}")

# Ustaw handler raportów doręczeń
client.set_message_received_handler(lambda pdu: handle_delivery_report(pdu))

Kompletny przykład klienta SMPP API w Pythonie do wysyłania SMS-ów

Oto kompletny działający przykład:

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)
        
        # Połącz z serwerem
        self.client.connect()
        self.client.bind_transceiver(
            system_id=system_id,
            password=password,
        )
        
        # Uruchom keep-alive
        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"Ponowne połączenie nieudane: {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"Wysyłanie nieudane: {e}")
            return None
    
    def handle_message(self, pdu):
        if pdu.command == "deliver_sm":
            print(f"Raport doręczenia: {pdu.receipted_message_id} - {pdu.message_state}")
        else:
            print(f"Otrzymano wiadomość: {pdu.short_message}")

# Użycie
if __name__ == "__main__":
    client = SMPPClient(
        host="your.ozeki.server",
        port=2775,
        system_id="your_username",
        password="your_password"
    )
    
    # Wyślij wiadomość
    client.send_sms(
        from_addr="12345",
        to_addr="+1234567890",
        message="Witaj z kompletnego klienta SMPP w Pythonie!"
    )
    
    # Utrzymuj działanie
    while True:
        time.sleep(1)

Podsumowanie

Ten przewodnik pokazał, jak pracować z interfejsem SMPP API na poziomie protokołu przy użyciu Pythona. Implementując te przykłady z Ozeki SMS Gateway, możesz budować solidne aplikacje SMS z funkcjami takimi jak zarządzanie połączeniami, wysyłanie wiadomości i obsługa raportów doręczeń. Biblioteka smpplib zapewnia wygodny sposób pracy z PDU SMPP, jednocześnie zajmując się szczegółami niskopoziomowego protokołu za Ciebie.

Pamiętaj, aby w kodzie produkcyjnym właściwie obsługiwać wyjątki i zaimplementować logikę ponownego łączenia dla maksymalnej niezawodności. Podany kompletny przykład zawiera podstawową obsługę ponownego łączenia i funkcjonalność keep-alive.