As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Enviar mensagens SMS usando o Amazon SNS
<a name="sms_sending-overview"></a>

Esta seção descreve como enviar mensagens SMS usando o Amazon SNS, incluindo publicar em um tópico, inscrever números de telefone em tópicos, definir atributos em mensagens e publicar diretamente em telefones celulares.

## Publicar mensagens de SMS em um tópico do Amazon SNS
<a name="sms_publish-to-topic"></a>

É possível publicar uma única mensagem SMS em vários números de telefone de uma só vez inscrevendo esses números de telefone em um tópico do Amazon SNS. Um tópico do Amazon SNS é um canal de comunicação para o qual é possível adicionar inscritos e publicar mensagens para todos esses inscritos. Um assinante recebe todas as mensagens publicadas no tópico até que você cancele a assinatura ou até que o assinante opte por não receber mensagens SMS da sua conta. AWS 

### Enviando uma mensagem para um tópico usando o AWS console
<a name="sms_publish-to-topic_console"></a>

**Para criar um tópico**

Realize as seguintes etapas se você ainda não tiver um tópico para o qual deseja enviar mensagens SMS.

1. Faça login no [console do Amazon SNS](https://console.aws.amazon.com/sns/home).

1. No menu do console, selecione uma [região compatível com mensagens SMS](https://docs.aws.amazon.com/general/latest/gr/end-user-messaging.html).

1. No painel de navegação, escolha **Tópicos**.

1. Na página **Topics** (Tópicos), escolha **Create topic** (Criar tópico).

1. Na página **Create topic** (Criar tópico), em **Details** (Detalhes), faça o seguinte:

   1. Em **Tipo**, escolha **Padrão**.

   1. Em **Name** (Nome), insira um nome para o tópico.

   1. (Opcional) Para **Display name** (Nome de exibição), digite um prefixo personalizado para suas mensagens SMS. Quando você envia uma mensagem para o tópico, o Amazon SNS acrescenta o nome de exibição seguido por uma seta para a direita (>) e um espaço. Os nomes de exibição não fazem distinção entre maiúsculas e minúsculas e o Amazon SNS converte os nomes de exibição para caracteres maiúsculos. Por exemplo, se o nome de exibição de um tópico é `MyTopic` e a mensagem é `Hello World!`, a mensagem é exibida como:

      ```
      MYTOPIC> Hello World!
      ```

1. Escolha **Criar tópico**. O nome do tópico e o nome do recurso da Amazon (ARN) aparecem na página **Topics** (Tópicos).

**Para criar uma assinatura de SMS**

Use assinaturas para enviar uma mensagem SMS para vários destinatários publicando a mensagem somente uma vez em seu tópico.
**nota**  
Quando você começa a usar o Amazon SNS para enviar mensagens SMS, sua AWS conta está na sandbox de *SMS*. A sandbox de SMS oferece um ambiente seguro para testar os recursos do Amazon SNS sem arriscar a reputação como remetente do SMS. Enquanto sua conta estiver na sandbox de SMS, é possível usar todos os recursos do Amazon SNS, mas as mensagens SMS podem ser enviadas somente para números de telefone de destino verificados. Para obter mais informações, consulte [Usar sandbox de SMS do Amazon SNS](sns-sms-sandbox.md).

1. Faça login no [console do Amazon SNS](https://console.aws.amazon.com/sns/home).

1. No painel de navegação, escolha **Assinaturas**.

1. Na página **Assinaturas**, escolha **Criar assinatura**.

1. Na página **Create subscription** (Criar assinatura), na seção **Details** (Detalhes), faça o seguinte:

   1. Em **Topic ARN** (ARN do tópico), insira ou escolha o nome do recurso da Amazon (ARN) do tópico para o qual você deseja enviar mensagens SMS.

   1. Para **Protocol** (Protocolo), escolha **SMS**.

   1. Para **Endpoint** digite o número de telefone que você deseja assinar para seu tópico.

1. Selecione **Criar assinatura**. As informações da assinatura são exibidas na página **Subscriptions** (Assinaturas).

   Para adicionar mais números de telefone, repita essas etapas. Também é possível adicionar outros tipos de assinaturas, como e-mail.

**Para enviar uma mensagem**

Quando você publica uma mensagem em um tópico, o Amazon SNS tenta entregar essa mensagem para cada número de telefone inscrito no tópico.

1. No [console do Amazon SNS](https://console.aws.amazon.com/sns/home), na página **Topics** (Tópicos), escolha o nome do tópico para o qual você deseja enviar mensagens SMS.

1. Na página de detalhes do tópico, selecione **Publicar mensagem**.

1. Na página **Publish message to topic** (Publicar mensagem no tópico), em **Message details** (Detalhes da mensagem), faça o seguinte:

   1. Em **Subject** (Assunto), deixe o campo em branco, a menos que o tópico contenha inscrições de e-mail e você queira publicar nas inscrições por e-mail e por SMS. O Amazon SNS usará o **Subject** (Assunto) que você inserir como linha de assunto do e-mail.

   1. (Opcional) Para**Time to Live (TTL)** (Vida útil (TTL)), insira o número de segundos que o Amazon SNS tem para enviar sua mensagem SMS para qualquer assinante de endpoint de aplicação móvel.

1. Em **Message body** (Corpo da mensagem), faça o seguinte:

   1. Em **Message structure** (Estrutura de mensagem), escolha **Identical payload for all delivery protocols** (Carga útil idêntica para todos os protocolos de entrega) para enviar a mesma mensagem para todos os tipos de protocolo inscritos no tópico. Ou escolha **Custom payload for each delivery protocol** (Carga útil personalizada para cada protocolo de entrega) para personalizar a mensagem direcionada a assinantes de diferentes tipos de protocolo. Por exemplo, é possível inserir uma mensagem padrão para assinantes de número de telefone e uma mensagem personalizada para assinantes de e-mail.

   1. Em **Message body to send to the endpoint** (Corpo da mensagem a ser enviada para o endpoint), insira sua mensagem ou suas mensagens personalizadas por protocolo de entrega.

      Se o tópico tem um nome de exibição, o Amazon SNS adiciona-o à mensagem, o que aumenta o tamanho da mensagem. O tamanho do nome de exibição é o número de caracteres no nome, mais dois caracteres para a seta (>) e o espaço adicionado pelo Amazon SNS.

      Para obter mais informações sobre as cotas de tamanho de mensagens SMS, consulte [Publicação de mensagens SMS em um telefone celular usando o Amazon SNS](#sms_publish-to-phone).

1. (Opcional) Para **atributos de mensagem**, adicione metadados de mensagem, como carimbos de data/hora, assinaturas e. IDs

1. Selecione **Publish message (Publicar mensagem)**. O Amazon SNS envia a mensagem SMS e exibe uma mensagem de êxito.

### Enviar uma mensagem para um tópico usando o AWS SDKs
<a name="sms_publish-to-topic_sdk"></a>

Para usar um AWS SDK, você deve configurá-lo com suas credenciais. Para obter mais informações, consulte [Os arquivos compartilhados de configuração e credenciais no Guia](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) de *referência de ferramentas AWS SDKs e ferramentas*.

O código de exemplo a seguir mostra como:
+ Criar um tópico do Amazon SNS.
+ Inscrever números de telefone no tópico.
+ Publicar mensagens SMS no tópico para que todos os números de telefone inscritos recebam a mensagem de uma só vez.

------
#### [ Java ]

**SDK para Java 2.x**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/sns#code-examples). 
Criar um tópico e retorne seu ARN.  

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.CreateTopicRequest;
import software.amazon.awssdk.services.sns.model.CreateTopicResponse;
import software.amazon.awssdk.services.sns.model.SnsException;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class CreateTopic {
    public static void main(String[] args) {
        final String usage = """

                Usage:    <topicName>

                Where:
                   topicName - The name of the topic to create (for example, mytopic).

                """;

        if (args.length != 1) {
            System.out.println(usage);
            System.exit(1);
        }

        String topicName = args[0];
        System.out.println("Creating a topic with name: " + topicName);
        SnsClient snsClient = SnsClient.builder()
                .region(Region.US_EAST_1)
                .build();

        String arnVal = createSNSTopic(snsClient, topicName);
        System.out.println("The topic ARN is" + arnVal);
        snsClient.close();
    }

    public static String createSNSTopic(SnsClient snsClient, String topicName) {
        CreateTopicResponse result;
        try {
            CreateTopicRequest request = CreateTopicRequest.builder()
                    .name(topicName)
                    .build();

            result = snsClient.createTopic(request);
            return result.topicArn();

        } catch (SnsException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }
}
```
Inscreva um endpoint em um tópico.  

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.SnsException;
import software.amazon.awssdk.services.sns.model.SubscribeRequest;
import software.amazon.awssdk.services.sns.model.SubscribeResponse;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class SubscribeTextSMS {
    public static void main(String[] args) {
        final String usage = """

                Usage:    <topicArn> <phoneNumber>

                Where:
                   topicArn - The ARN of the topic to subscribe.
                   phoneNumber - A mobile phone number that receives notifications (for example, +1XXX5550100).
                """;

        if (args.length < 2) {
            System.out.println(usage);
            System.exit(1);
        }

        String topicArn = args[0];
        String phoneNumber = args[1];
        SnsClient snsClient = SnsClient.builder()
                .region(Region.US_EAST_1)
                .build();

        subTextSNS(snsClient, topicArn, phoneNumber);
        snsClient.close();
    }

    public static void subTextSNS(SnsClient snsClient, String topicArn, String phoneNumber) {
        try {
            SubscribeRequest request = SubscribeRequest.builder()
                    .protocol("sms")
                    .endpoint(phoneNumber)
                    .returnSubscriptionArn(true)
                    .topicArn(topicArn)
                    .build();

            SubscribeResponse result = snsClient.subscribe(request);
            System.out.println("Subscription ARN: " + result.subscriptionArn() + "\n\n Status is "
                    + result.sdkHttpResponse().statusCode());

        } catch (SnsException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }
}
```
Defina atributos na mensagem, como o ID do remetente, o preço máximo e seu tipo. Os atributos de mensagem são opcionais.  

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.SetSmsAttributesRequest;
import software.amazon.awssdk.services.sns.model.SetSmsAttributesResponse;
import software.amazon.awssdk.services.sns.model.SnsException;
import java.util.HashMap;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class SetSMSAttributes {
    public static void main(String[] args) {
        HashMap<String, String> attributes = new HashMap<>(1);
        attributes.put("DefaultSMSType", "Transactional");
        attributes.put("UsageReportS3Bucket", "janbucket");

        SnsClient snsClient = SnsClient.builder()
                .region(Region.US_EAST_1)
                .build();
        setSNSAttributes(snsClient, attributes);
        snsClient.close();
    }

    public static void setSNSAttributes(SnsClient snsClient, HashMap<String, String> attributes) {
        try {
            SetSmsAttributesRequest request = SetSmsAttributesRequest.builder()
                    .attributes(attributes)
                    .build();

            SetSmsAttributesResponse result = snsClient.setSMSAttributes(request);
            System.out.println("Set default Attributes to " + attributes + ". Status was "
                    + result.sdkHttpResponse().statusCode());

        } catch (SnsException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }
}
```
Publique uma mensagem em um tópico. A mensagem é enviada para todos os assinantes.  

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.PublishRequest;
import software.amazon.awssdk.services.sns.model.PublishResponse;
import software.amazon.awssdk.services.sns.model.SnsException;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class PublishTextSMS {
    public static void main(String[] args) {
        final String usage = """

                Usage:    <message> <phoneNumber>

                Where:
                   message - The message text to send.
                   phoneNumber - The mobile phone number to which a message is sent (for example, +1XXX5550100).\s
                """;

        if (args.length != 2) {
            System.out.println(usage);
            System.exit(1);
        }

        String message = args[0];
        String phoneNumber = args[1];
        SnsClient snsClient = SnsClient.builder()
                .region(Region.US_EAST_1)
                .build();
        pubTextSMS(snsClient, message, phoneNumber);
        snsClient.close();
    }

    public static void pubTextSMS(SnsClient snsClient, String message, String phoneNumber) {
        try {
            PublishRequest request = PublishRequest.builder()
                    .message(message)
                    .phoneNumber(phoneNumber)
                    .build();

            PublishResponse result = snsClient.publish(request);
            System.out
                    .println(result.messageId() + " Message sent. Status was " + result.sdkHttpResponse().statusCode());

        } catch (SnsException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }
}
```

------

## Publicação de mensagens SMS em um telefone celular usando o Amazon SNS
<a name="sms_publish-to-phone"></a>

É possível usar o Amazon SNS para enviar mensagens SMS diretamente para um telefone celular sem inscrever o número de telefone em um tópico do Amazon SNS.

**nota**  
A inscrição de números de telefone em um tópico é útil se você quer enviar uma mensagem para vários números de telefone de uma só vez. Para obter instruções sobre como publicar uma mensagem SMS em um tópico, consulte [Publicar mensagens de SMS em um tópico do Amazon SNS](#sms_publish-to-topic).

Ao enviar uma mensagem, é possível controlar se a mensagem é otimizada para custos ou confiabilidade de entrega. Também é possível especificar um [ID do remetente ou número de origem](channels-sms-originating-identities.md). Se você enviar a mensagem programaticamente usando a API do Amazon SNS ou AWS SDKs a, você pode especificar um preço máximo para a entrega da mensagem.

Cada mensagem SMS pode ter até 140 bytes, e a cota de caracteres depende do esquema de codificação. Por exemplo, uma mensagem SMS pode incluir:
+ 160 caracteres GSM
+ 140 caracteres ASCII
+ 70 caracteres UCS-2

Se você publicar uma mensagem que exceda a cota de tamanho, o Amazon SNS a enviará como várias mensagens, cada uma delas respeitando a cota de tamanho. Para isso, as palavras são mantidas inteiras na mensagem, não cortadas. O tamanho total da cota de uma única ação de publicação de SMS é de 1.600 bytes.

Ao enviar uma mensagem SMS, você especifica o número de telefone com o formato E.164, que é uma estrutura padrão de numeração de telefones para telecomunicação internacional. Os números de telefone que seguem esse formato podem conter no máximo 15 dígitos junto como prefixo de um sinal de adição (\$1) e o código do país. Por exemplo, um número de telefone dos EUA no formato E.164 aparece como \$11. XXX5550100

### Enviar uma mensagem (console)
<a name="sms_publish_console"></a>

1. Faça login no console [do Amazon SNS](https://console.aws.amazon.com/sns/home).

1. No menu do console, selecione uma [região compatível com mensagens SMS](https://docs.aws.amazon.com/general/latest/gr/end-user-messaging.html).

1. No painel de navegação, escolha **Mensagens de texto (SMS)**.

1. Na página **Mobile text messaging (SMS)** (Mensagens de texto para dispositivos móveis (SMS)), selecione **Publish text message** (Publicar mensagem de texto).

1. Na página **Publish SMS message** (Publicar mensagem SMS), para **Message type** (Tipo de mensagem), escolha uma das seguintes opções:
   + **Promotional** (Promocional): mensagens não essenciais, como mensagens de marketing.
   + **Transactional** (Transacional): mensagens urgentes que oferecem suporte para transações do cliente, como senhas únicas para autenticação multifator.
**nota**  
Essa configuração em nível de mensagem substitui o tipo de mensagem padrão em nível de conta. É possível definir um tipo de mensagem padrão em nível de conta na seção **Text messaging preferences** (Opções de mensagens de texto) da página **Mobile text messaging (SMS)** (Mensagens de texto para dispositivos móveis (SMS)).

   Para obter informações sobre mensagens promocionais e transacionais, consulte [Worldwide SMS Pricing](https://aws.amazon.com/sns/sms-pricing/) (Preço global para SMS).

1. Em **Destination phone number** (Número de telefone de destino), digite o número de telefone para o qual você deseja enviar a mensagem.

1. Em **Message** (Mensagem), digite a mensagem a ser enviada.

1. (Opcional) Em **Origination identities** (Identidades de origem), especifique como você se identificará para seus destinatários:
   + Para especificar um **Sender ID** (ID do remetente), digite um ID personalizado que contenha de 3 a 11 caracteres alfanuméricos sem espaços, com pelo menos uma letra. O ID do remetente é exibido como o remetente da mensagem no dispositivo receptor. Por exemplo, é possível usar a marca de sua empresa para tornar a origem da mensagem mais fácil de reconhecer.

     Support para remetente IDs varia de acordo com o país e a and/or região. Por exemplo, as mensagens enviadas para os números de telefone dos EUA não exibirão o ID do remetente. Para os países e regiões que oferecem suporte ao remetente IDs, consulte [Países e regiões com suporte para mensagens SMS AWS End User Messaging SMS](https://docs.aws.amazon.com/sms-voice/latest/userguide/phone-numbers-sms-by-country.html) no *Guia do AWS End User Messaging SMS usuário*.

     Se você não especificar um ID do remetente, uma das seguintes informações será exibida como identidade de origem:
     + Em países com suporte para códigos longos, o código longo será exibido.
     + Em países onde somente o remetente IDs é suportado, o *AVISO* é exibido.

     Esse ID do remetente no nível de mensagem substitui o ID de remetente padrão, que você define na página **Preferências de mensagens de texto**.
   + Para especificar um **Origination number** (Número de origem), insira uma string de 5 a 14 números para ser exibida como número de telefone do remetente no dispositivo do receptor. Essa sequência de caracteres deve corresponder a um número de origem configurado em seu Conta da AWS para o país de destino. O número de origem pode ser um número 10DLC, um número gratuito, um código person-to-person longo ou um código curto. Para obter mais informações, consulte [Identidades de origem para mensagens do Amazon SNS SMS](channels-sms-originating-identities.md).

     Se você não especificar um número de origem, o Amazon SNS selecionará um número de origem a ser usado para a mensagem de texto SMS, com base na configuração de sua Conta da AWS .

1. Se você estiver enviando mensagens SMS para destinatários na Índia, expanda **Country-specific attributes** (Atributos específicos do país) e especifique estes atributos:
   + **Entity ID** (ID da entidade): o ID da entidade ou ID da Principal Entity (PE – Entidade principal) para enviar mensagens SMS a destinatários na Índia. Esse ID é uma string exclusiva de 1 a 50 caracteres que a Telecom Regulatory Authority of India (TRAI) fornece para identificar a entidade que você registrou junto a ela.
   + **Template ID** (ID do modelo): o ID de modelo para enviar mensagens SMS a destinatários na Índia. Esse ID é uma string exclusiva de 1 a 50 caracteres fornecida pela TRAI que identifica o modelo que você registrou junto a ela. O ID do modelo deve ser associado ao ID do remetente que você especificou para a mensagem.

   Para obter mais informações sobre como enviar mensagens SMS para destinatários na [Índia, consulte o processo de registro de IDs do remetente](https://docs.aws.amazon.com/sms-voice/latest/userguide/registrations-sms-senderid-india.html) no *Guia do Usuário do AWS End User Messaging SMS *.

1. Selecione **Publish message (Publicar mensagem)**.

**dica**  
Para enviar mensagens SMS de um número de origem, você também pode escolher **Origination numbers** (Números de origem) no painel de navegação do console do Amazon SNS. Escolha um número de origem que inclua **SMS** na coluna **Capacities** (Recursos) e, em seguida, escolha **Publish text message** (Publicar mensagem de texto).

### Enviando uma mensagem (AWS SDKs)
<a name="sms_publish_sdk"></a>

Para enviar uma mensagem SMS usando um dos AWS SDKs, use a operação de API nesse SDK que corresponde à `Publish` solicitação na API do Amazon SNS. Com essa solicitação, você pode enviar uma mensagem SMS diretamente para um número de telefone. Você também pode usar o parâmetro `MessageAttributes` para definir valores para os seguintes nomes de atributos:

**`AWS.SNS.SMS.SenderID`**  
Um ID personalizado que contenha de 3 a 11 caracteres alfanuméricos ou caracteres de hífen (-) sem espaços, com pelo menos uma letra. O ID do remetente é exibido como o remetente da mensagem no dispositivo receptor. Por exemplo, é possível usar a marca de sua empresa para ajudar a tornar a origem da mensagem mais fácil de reconhecer.  
Support para remetente IDs varia de acordo com o país ou a região. Por exemplo, as mensagens enviadas para os números de telefone dos EUA não exibem o ID do remetente. Para obter uma lista dos países ou regiões que oferecem suporte ao remetente IDs, consulte [Países e regiões com suporte para mensagens SMS AWS End User Messaging SMS](https://docs.aws.amazon.com/sms-voice/latest/userguide/phone-numbers-sms-by-country.html) no *Guia do AWS End User Messaging SMS usuário*.  
Se você não especificar um ID do remetente, um [código longo](https://docs.aws.amazon.com/sms-voice/latest/userguide/phone-numbers-request-long-code.html) será exibido como o ID do remetente nos países ou regiões compatíveis. Para países ou regiões que exigem um ID do remetente alfabético, um *AVISO* será exibido como o ID do remetente.  
Esse atributo de mensagem substitui o atributo no nível da contas `DefaultSenderID` que você pode definir usando a solicitação `SetSMSAttributes`.

**`AWS.MM.SMS.OriginationNumber`**  
Uma string personalizada de 5 a 14 números, que pode incluir um sinal de adição opcional à esquerda (`+`). Essa string numérica aparece como o número de telefone do remetente no dispositivo receptor. A sequência de caracteres deve corresponder a um número de origem configurado na sua AWS conta para o país de destino. O número de origem pode ser um número 10DLC, número gratuito, código longo person-to-person (P2P) ou código curto. Para obter mais informações, consulte [Números de telefone](https://docs.aws.amazon.com/sms-voice/latest/userguide/phone-numbers.html) no *Guia do usuário do AWS End User Messaging SMS *.  
Se você não especificar um número de originação, o Amazon SNS escolherá um número de origem com base na configuração da sua conta. AWS 

**`AWS.SNS.SMS.MaxPrice`**  
O preço máximo em USD que você está disposto a gastar para enviar a mensagem SMS. Se o Amazon SNS determinar que enviar a mensagem pode gerar um custo que ultrapassaria o preço máximo, ele não enviará a mensagem.  
Esse atributo não tem efeito se seus custos de month-to-date SMS já tiverem excedido a cota definida para o `MonthlySpendLimit` atributo. É possível definir o atributo `MonthlySpendLimit` usando a solicitação `SetSMSAttributes`.  
Se você está enviando a mensagem para um tópico do Amazon SNS, o preço máximo se aplica a cada entrega de mensagem para cada número de telefone inscrito no tópico.

**`AWS.SNS.SMS.SMSType`**  
O tipo de mensagem que você está enviando:  
+ **`Promotional`** (padrão): mensagens não essenciais, como mensagens de marketing.
+ **`Transactional`**: mensagens essenciais que oferecem suporte a transações do cliente, como senhas únicas para autenticação multifator.
Esse atributo de mensagem substitui o atributo no nível da contas `DefaultSMSType` que você pode definir usando a solicitação `SetSMSAttributes`.

**`AWS.MM.SMS.EntityId`**  
Esse atributo é necessário somente para enviar mensagens SMS a destinatários na Índia.  
Esse é o ID da entidade ou ID da Principal Entity (PE – Entidade principal) para enviar mensagens SMS a destinatários na Índia. Esse ID é uma string exclusiva de 1 a 50 caracteres que a Telecom Regulatory Authority of India (TRAI) fornece para identificar a entidade que você registrou junto a ela.

**`AWS.MM.SMS.TemplateId`**  
Esse atributo é necessário somente para enviar mensagens SMS a destinatários na Índia.  
Este é o seu modelo para enviar mensagens SMS a destinatários na Índia. Esse ID é uma string exclusiva de 1 a 50 caracteres fornecida pela TRAI que identifica o modelo que você registrou junto a ela. O ID do modelo deve ser associado ao ID do remetente que você especificou para a mensagem.

#### Enviar uma mensagem
<a name="sms_publish_sdks"></a>

Os exemplos de código a seguir mostram como publicar mensagens SMS usando o Amazon SNS.

------
#### [ .NET ]

**SDK para .NET**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/SNS#code-examples). 

```
namespace SNSMessageExample
{
    using System;
    using System.Threading.Tasks;
    using Amazon;
    using Amazon.SimpleNotificationService;
    using Amazon.SimpleNotificationService.Model;

    public class SNSMessage
    {
        private AmazonSimpleNotificationServiceClient snsClient;

        /// <summary>
        /// Initializes a new instance of the <see cref="SNSMessage"/> class.
        /// Constructs a new SNSMessage object initializing the Amazon Simple
        /// Notification Service (Amazon SNS) client using the supplied
        /// Region endpoint.
        /// </summary>
        /// <param name="regionEndpoint">The Amazon Region endpoint to use in
        /// sending test messages with this object.</param>
        public SNSMessage(RegionEndpoint regionEndpoint)
        {
            snsClient = new AmazonSimpleNotificationServiceClient(regionEndpoint);
        }

        /// <summary>
        /// Sends the SMS message passed in the text parameter to the phone number
        /// in phoneNum.
        /// </summary>
        /// <param name="phoneNum">The ten-digit phone number to which the text
        /// message will be sent.</param>
        /// <param name="text">The text of the message to send.</param>
        /// <returns>Async task.</returns>
        public async Task SendTextMessageAsync(string phoneNum, string text)
        {
            if (string.IsNullOrEmpty(phoneNum) || string.IsNullOrEmpty(text))
            {
                return;
            }

            // Now actually send the message.
            var request = new PublishRequest
            {
                Message = text,
                PhoneNumber = phoneNum,
            };

            try
            {
                var response = await snsClient.PublishAsync(request);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error sending message: {ex}");
            }
        }
    }
}
```
+  Consulte detalhes da API em [Publish](https://docs.aws.amazon.com/goto/DotNetSDKV3/sns-2010-03-31/Publish) na *Referência da API AWS SDK para .NET *. 

------
#### [ C\$1\$1 ]

**SDK para C\$1\$1**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sns#code-examples). 

```
/**
 * Publish SMS: use Amazon Simple Notification Service (Amazon SNS) to send an SMS text message to a phone number.
 * Note: This requires additional AWS configuration prior to running example. 
 * 
 *  NOTE: When you start using Amazon SNS to send SMS messages, your AWS account is in the SMS sandbox and you can only
 *  use verified destination phone numbers. See https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html.
 *  NOTE: If destination is in the US, you also have an additional restriction that you have use a dedicated
 *  origination ID (phone number). You can request an origination number using Amazon Pinpoint for a fee.
 *  See https://aws.amazon.com/blogs/compute/provisioning-and-using-10dlc-origination-numbers-with-amazon-sns/ 
 *  for more information. 
 * 
 *  <phone_number_value> input parameter uses E.164 format. 
 *  For example, in United States, this input value should be of the form: +12223334444
 */

//! Send an SMS text message to a phone number.
/*!
  \param message: The message to publish.
  \param phoneNumber: The phone number of the recipient in E.164 format.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */
bool AwsDoc::SNS::publishSms(const Aws::String &message,
                             const Aws::String &phoneNumber,
                             const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::SNS::SNSClient snsClient(clientConfiguration);

    Aws::SNS::Model::PublishRequest request;
    request.SetMessage(message);
    request.SetPhoneNumber(phoneNumber);

    const Aws::SNS::Model::PublishOutcome outcome = snsClient.Publish(request);

    if (outcome.IsSuccess()) {
        std::cout << "Message published successfully with message id, '"
                  << outcome.GetResult().GetMessageId() << "'."
                  << std::endl;
    }
    else {
        std::cerr << "Error while publishing message "
                  << outcome.GetError().GetMessage()
                  << std::endl;
    }

    return outcome.IsSuccess();
}
```
+  Consulte detalhes da API em [Publish](https://docs.aws.amazon.com/goto/SdkForCpp/sns-2010-03-31/Publish) na *Referência da API AWS SDK para C\$1\$1 *. 

------
#### [ Java ]

**SDK para Java 2.x**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/sns#code-examples). 

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.PublishRequest;
import software.amazon.awssdk.services.sns.model.PublishResponse;
import software.amazon.awssdk.services.sns.model.SnsException;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class PublishTextSMS {
    public static void main(String[] args) {
        final String usage = """

                Usage:    <message> <phoneNumber>

                Where:
                   message - The message text to send.
                   phoneNumber - The mobile phone number to which a message is sent (for example, +1XXX5550100).\s
                """;

        if (args.length != 2) {
            System.out.println(usage);
            System.exit(1);
        }

        String message = args[0];
        String phoneNumber = args[1];
        SnsClient snsClient = SnsClient.builder()
                .region(Region.US_EAST_1)
                .build();
        pubTextSMS(snsClient, message, phoneNumber);
        snsClient.close();
    }

    public static void pubTextSMS(SnsClient snsClient, String message, String phoneNumber) {
        try {
            PublishRequest request = PublishRequest.builder()
                    .message(message)
                    .phoneNumber(phoneNumber)
                    .build();

            PublishResponse result = snsClient.publish(request);
            System.out
                    .println(result.messageId() + " Message sent. Status was " + result.sdkHttpResponse().statusCode());

        } catch (SnsException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }
}
```
+  Consulte detalhes da API em [Publish](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/Publish) na *Referência da API AWS SDK for Java 2.x *. 

------
#### [ Kotlin ]

**SDK para Kotlin**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/sns#code-examples). 

```
suspend fun pubTextSMS(
    messageVal: String?,
    phoneNumberVal: String?,
) {
    val request =
        PublishRequest {
            message = messageVal
            phoneNumber = phoneNumberVal
        }

    SnsClient.fromEnvironment { region = "us-east-1" }.use { snsClient ->
        val result = snsClient.publish(request)
        println("${result.messageId} message sent.")
    }
}
```
+  Consulte detalhes da API em [Publish](https://sdk.amazonaws.com/kotlin/api/latest/index.html) na *Referência da API AWS SDK para Kotlin*. 

------
#### [ PHP ]

**SDK para PHP**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [Repositório de exemplos de código da AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/sns#code-examples). 

```
require 'vendor/autoload.php';

use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;


/**
 * Sends a text message (SMS message) directly to a phone number using Amazon SNS.
 *
 * This code expects that you have AWS credentials set up per:
 * https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
 */

$SnSclient = new SnsClient([
    'profile' => 'default',
    'region' => 'us-east-1',
    'version' => '2010-03-31'
]);

$message = 'This message is sent from a Amazon SNS code sample.';
$phone = '+1XXX5550100';

try {
    $result = $SnSclient->publish([
        'Message' => $message,
        'PhoneNumber' => $phone,
    ]);
    var_dump($result);
} catch (AwsException $e) {
    // output error message if fails
    error_log($e->getMessage());
}
```
+  Para obter mais informações, consulte o [Guia do desenvolvedor do AWS SDK para PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-sending-sms.html#publish-to-a-text-message-sms-message). 
+  Para obter detalhes da API, consulte [Publish](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Publish) na *Referência da API do AWS SDK para PHP *. 

------
#### [ Python ]

**SDK para Python (Boto3)**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/sns#code-examples). 

```
class SnsWrapper:
    """Encapsulates Amazon SNS topic and subscription functions."""

    def __init__(self, sns_resource):
        """
        :param sns_resource: A Boto3 Amazon SNS resource.
        """
        self.sns_resource = sns_resource


    def publish_text_message(self, phone_number, message):
        """
        Publishes a text message directly to a phone number without need for a
        subscription.

        :param phone_number: The phone number that receives the message. This must be
                             in E.164 format. For example, a United States phone
                             number might be +12065550101.
        :param message: The message to send.
        :return: The ID of the message.
        """
        try:
            response = self.sns_resource.meta.client.publish(
                PhoneNumber=phone_number, Message=message
            )
            message_id = response["MessageId"]
            logger.info("Published message to %s.", phone_number)
        except ClientError:
            logger.exception("Couldn't publish message to %s.", phone_number)
            raise
        else:
            return message_id
```
+  Consulte detalhes da API em [Publish](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/Publish) na *Referência da API AWS SDK for Python (Boto3)*. 

------
#### [ SAP ABAP ]

**SDK para SAP ABAP**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/sns#code-examples). 

```
    " iv_phone_number = '+12065550101' - Phone number in E.164 format
    TRY.
        oo_result = lo_sns->publish(              " oo_result is returned for testing purposes. "
          iv_phonenumber = iv_phone_number
          iv_message = iv_message ).
        MESSAGE 'Message published to phone number.' TYPE 'I'.
      CATCH /aws1/cx_snsnotfoundexception.
        MESSAGE 'Phone number does not exist.' TYPE 'E'.
    ENDTRY.
```
+  Para obter os detalhes da API, consulte [Publicar](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) na *Referência da API do AWS SDK para SAP ABAP*. 

------