Como Enviar SMS através da API SMPP usando Python

A API SMPP (Short Message Peer-to-Peer) é um protocolo poderoso para trocar mensagens SMS entre Entidades de Mensagens Curtas Externas (ESMEs) e Centros de Serviço de Mensagens Curtas (SMSCs). Para desenvolvedores que usam o Ozeki SMS Gateway, utilizar a API SMPP com Python permite uma integração perfeita de SMS para aplicações. Este guia abrangente fornece instruções passo a passo, exemplos práticos de código em Python e melhores práticas para estabelecer, manter e usar uma conexão com a API SMPP para enviar mensagens SMS de forma eficiente.

A simplicidade do Python e suas bibliotecas robustas, como smpplib, tornam-no uma escolha ideal para integração com a API SMPP. O protocolo SMPP permite entrega de SMS de alto desempenho, relatórios de entrega em tempo real e gerenciamento confiável de conexão. Ao combinar Python com a API SMPP, desenvolvedores podem criar soluções escaláveis de SMS para aplicações como notificações, campanhas de marketing ou autenticação de dois fatores (2FA).

1. Verifique as Credenciais SMPP: Certifique-se de ter o host, porta, nome de usuário e senha corretos para o seu usuário SMPP no Ozeki SMS Gateway.
2. Escreva e Execute o Código Python: Use a biblioteca smpplib para criar um script que conecta ao servidor SMPP e envia SMS.
3. Verifique os Resultados: Confirme a entrega bem-sucedida das mensagens através dos logs na interface do Ozeki SMS Gateway.

Assista a este tutorial em vídeo passo a passo para aprender como enviar mensagens SMS usando Python e a API SMPP com o Ozeki SMS Gateway. O tutorial cobre a configuração de um usuário SMPP, conexão com a biblioteca smpplib, envio de mensagens, manutenção de conexões e tratamento de relatórios de entrega.

Passo 1: Selecione Seu Usuário SMPP

Na interface do Ozeki SMS Gateway, navegue até a seção "Usuários e Aplicações". Selecione ou crie um usuário SMPP para estabelecer uma conexão a partir do seu script Python. Este usuário autenticará sua aplicação com o servidor SMPP.

Passo 2: Obtenha os Detalhes de Conexão

Após selecionar seu usuário SMPP, vá para a aba "Ajuda" na interface do Ozeki SMS Gateway. Aqui, você encontrará os detalhes essenciais de conexão, incluindo o endereço IP, número da porta, nome de usuário e senha. Essas credenciais são críticas para configurar seu script Python para conectar ao servidor SMPP.

Passo 3: Escreva o Código Python SMPP

Abra seu IDE ou editor de Python preferido e cole o código de conexão SMPP fornecido abaixo. Este código usa a biblioteca smpplib para estabelecer uma conexão com o Ozeki SMS Gateway e preparar o ambiente para enviar mensagens SMS.

Passo 4: Atualize as Credenciais SMPP

Substitua os valores de espaço reservado no código Python (host, porta, nome de usuário, senha, e números de telefone) com suas credenciais SMPP reais e o número de telefone do destinatário. Isso garante que seu script conecte ao servidor SMPP correto e envie mensagens para o destinatário pretendido.

Passo 5: Verifique a Conexão Bem-Sucedida

Execute seu script Python. Se configurado corretamente, a interface do Ozeki SMS Gateway registrará uma conexão bem-sucedida para seu usuário SMPP. Isso confirma que seu script Python está pronto para enviar mensagens SMS via API SMPP.

Como Estabelecer uma Conexão SMPP API em Python para Envio de SMS

Para enviar mensagens SMS usando a API SMPP, você deve primeiro configurar um usuário SMPP no Ozeki SMS Gateway e vincular seu cliente Python ao servidor SMPP. A biblioteca smpplib simplifica esse processo ao lidar com detalhes de protocolo de baixo nível. Abaixo está um exemplo de código Python para estabelecer uma conexão SMPP:

import smpplib

# Parâmetros de conexão SMPP
HOST = 'your.ozeki.server'
PORT = 2775
SYSTEM_ID = 'your_username'
PASSWORD = 'your_password'

# Inicializar cliente SMPP
client = smpplib.client.Client(HOST, PORT)

# Vincular como transmissor para enviar SMS
client.connect()
client.bind_transmitter(
    system_id=SYSTEM_ID,
    password=PASSWORD,
)

print("Conexão com o servidor SMPP estabelecida com sucesso usando Python")

Principais Unidades de Dados de Protocolo (PDUs) do SMPP

O protocolo SMPP depende de Unidades de Dados de Protocolo (PDUs) para gerenciar conexões e mensagens. Abaixo está uma tabela resumindo as principais PDUs usadas em Python para integração com a API SMPP:

Manutenção de uma Conexão SMPP API Estável em Python para Envio de SMS

Conexões SMPP requerem sinais periódicos de "keep-alive" para evitar timeouts. A PDU enquire_link é enviada a cada 30 segundos para manter a conexão. Abaixo está um exemplo em Python usando uma abordagem de threading para enviar sinais de keep-alive:

import time
import threading

def send_enquire_link():
    while True:
        try:
            client.enquire_link()
            print("PDU enquire_link enviada para manter a conexão SMPP")
        except Exception as e:
            print(f"Erro ao enviar enquire_link: {e}")
        time.sleep(30)  # Enviar a cada 30 segundos

# Iniciar thread de keep-alive
keepalive_thread = threading.Thread(target=send_enquire_link)
keepalive_thread.daemon = True
keepalive_thread.start()

Enviando SMS com Python através da API SMPP

Uma vez que a conexão é estabelecida, você pode enviar mensagens SMS usando o PDU submit_sm. O seguinte código Python demonstra como enviar um SMS e lidar com a resposta:

def send_sms(source_addr, destination_addr, message):
    try:
        # Enviar 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,  # Codificação GSM 7-bit
        )
        
        print(f"SMS enviado com sucesso, message_id: {pdu.message_id}")
        
    except smpplib.exceptions.PDUError as e:
        print(f"Erro SMPP PDU: {e}")
    except Exception as e:
        print(f"Erro ao enviar SMS: {e}")

# Exemplo de uso
send_sms(
    source_addr="12345",
    destination_addr="+1234567890",
    message="Olá do cliente Python SMPP!"
)

Tratando Relatórios de Entrega de SMS em Python

Para rastrear o status de entrega das mensagens SMS enviadas, você pode lidar com relatórios de entrega usando o PDU deliver_sm. Abaixo está um exemplo em Python para processar relatórios de entrega:

def handle_delivery_report(pdu):
    print(f"Relatório de entrega recebido para a mensagem {pdu.receipted_message_id}")
    print(f"Status: {pdu.message_state}")

# Configurar o manipulador de relatório de entrega
client.set_message_received_handler(lambda pdu: handle_delivery_report(pdu))

Exemplo Completo de Cliente Python SMPP API para Enviar SMS

Abaixo está um script Python completo e pronto para produção que se integra à API SMPP para enviar mensagens SMS, manter uma conexão estável e lidar com relatórios de entrega:

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)
        
        # Conectar ao servidor SMPP
        self.client.connect()
        self.client.bind_transceiver(
            system_id=system_id,
            password=password,
        )
        
        # Iniciar thread de keep-alive
        self.start_keepalive()
    
    def start_keepalive(self):
        def _keepalive():
            while True:
                try:
                    self.client.enquire_link()
                    print("Sinal de keep-alive enviado")
                except Exception:
                    try:
                        self.client.connect()
                        self.client.bind_transceiver(
                            system_id=system_id,
                            password=password,
                        )
                        print("Reconectado ao servidor SMPP")
                    except Exception as e:
                        print(f"Falha na reconexão: {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"Falha ao enviar SMS: {e}")
            return None
    
    def handle_message(self, pdu):
        if pdu.command == "deliver_sm":
            print(f"Relatório de entrega: {pdu.receipted_message_id} - {pdu.message_state}")
        else:
            print(f"Mensagem recebida: {pdu.short_message}")

# Exemplo de uso
if __name__ == "__main__":
    client = SMPPClient(
        host="your.ozeki.server",
        port=2775,
        system_id="your_username",
        password="your_password"
    )
    
    # Enviar um SMS
    client.send_sms(
        from_addr="12345",
        to_addr="+1234567890",
        message="Olá do cliente Python SMPP!"
    )
    
    # Manter o script em execução
    while True:
        time.sleep(1)

• Tratamento de Erros: Sempre implemente um tratamento robusto de exceções para gerenciar falhas de conexão, erros de PDU e timeouts.
• Reestabelecimento de Conexão: Inclua lógica para reconectar automaticamente se a conexão SMPP cair.
• Registro de Logs: Registre o status da conexão, mensagens enviadas e relatórios de entrega para depuração e monitoramento.
• Segurança: Armazene as credenciais SMPP com segurança, usando variáveis de ambiente ou um arquivo de configuração.
• Escalabilidade: Para aplicações de SMS de alto volume, considere usar bibliotecas assíncronas ou pool de conexões.

Este guia forneceu um passo a passo detalhado para integrar a API SMPP com Python usando o Ozeki SMS Gateway. Ao aproveitar a biblioteca smpplib, os desenvolvedores podem estabelecer conexões SMPP confiáveis, enviar mensagens SMS e lidar com relatórios de entrega com facilidade. Os exemplos de código Python e as melhores práticas fornecidas garantem aplicações de SMS robustas e escaláveis para diversos casos de uso, desde notificações até campanhas de marketing.

Nota: Para ambientes de produção, aprimore o código fornecido com tratamento abrangente de erros, lógica de reconexão e registro de logs para garantir máxima confiabilidade e desempenho.