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á. # Publicar uma mensagem do Amazon SNS Depois de [criar um tópico do Amazon SNS](sns-create-topic.md) e [inscrever](sns-create-subscribe-endpoint-to-topic.md) um endpoint nele, é possível *publicar* mensagens no tópico. Quando uma mensagem é publicada, o Amazon SNS tenta entregar a mensagem aos [endpoints](sns-create-subscribe-endpoint-to-topic.md#sns-endpoints) inscritos. ## Para publicar mensagens em tópicos do Amazon SNS usando o Console de gerenciamento da AWS 1. Faça login no console [do Amazon SNS](https://console.aws.amazon.com/sns/home). 1. No painel de navegação à esquerda, selecione **Tópicos**. 1. Na página **Topics** (Tópicos), selecione um tópico e escolha **Publish message** (Publicar em um tópico). O console abre a página **Publish message to topic** (Publicar mensagem no tópico). 1. Na seção **Basic details** (Detalhes básicos) faça o seguinte: 1. (Opcional) Insira o **Subject** (Assunto) de uma mensagem. 1. Para um [tópico FIFO](sns-fifo-topics.md), insira um **Message group ID** (ID do grupo de mensagens). O **ID do grupo de mensagens** é necessário para tópicos FIFO. As mensagens no mesmo grupo de mensagens são entregues na ordem em que são publicadas. 1. (Opcional) Para um tópico padrão, insira um **ID do grupo de mensagens**. Esse ID é encaminhado para todas as assinaturas padrão do Amazon SQS e não é usado nem enviado para nenhum outro tipo de endpoint. 1. Para um tópico FIFO, insira um **Message deduplication ID** (ID de desduplicação de mensagem). Este ID é opcional se você habilitou a configuração de **Desduplicação de mensagens baseada em conteúdo** para o tópico. 1. (Opcional) Para [notificações por push para dispositivos móveis](sns-ttl.md), insira um valor para **Time to Live (TTL)** (Vida útil (TTL)) em segundos. Esse é o tempo que um serviço de notificação push, como o Apple Push Notification Service (APNs) ou o Firebase Cloud Messaging (FCM), tem para entregar a mensagem ao endpoint. 1. Na seção **Message body (Corpo da mensagem)**, siga um destes procedimentos: 1. Escolha **Identical payload for all delivery protocols** (Carga útil idêntica para todos os protocolos de entrega) e, em seguida, insira uma mensagem. 1. Escolha **Custom payload for each delivery protocol** (Carga útil personalizada para cada protocolo de entrega) e, depois, insira um objeto JSON para definir a mensagem a ser enviada a cada protocolo de entrega. Para obter mais informações, consulte [Publicar notificações do Amazon SNS com cargas úteis específicas da plataforma](sns-send-custom-platform-specific-payloads-mobile-devices.md). 1. Na seção **Message attributes** (Atributos da mensagem), adicione todos os atributos que deseja que o Amazon SNS corresponda ao atributo de assinatura `FilterPolicy` para decidir se o endpoint inscrito está interessado na mensagem publicada. 1. Em **Type** Tipo, escolha um tipo de atributo, como **String.Array**. **nota** Para o tipo de atributo **String.Array**, coloque a matriz entre colchetes (`[]`). Dentro da matriz, coloque valores de strings entre aspas duplas. As aspas não são necessárias para números nem para as palavras-chave `true`, `false` e `null`. 1. Insira um atributo **Name** (Nome), por exemplo, `customer_interests`. 1. Insira um atributo **Value** (Valor), por exemplo, `["soccer", "rugby", "hockey"]`. Se o tipo do atributo for **String**, **String.Array** ou **Number**, o Amazon SNS avaliará o atributo de mensagem em relação à [política de filtro](sns-message-filtering.md) de uma assinatura (se existir) antes de enviar a mensagem à assinatura, considerando que o escopo da política de filtro não está explicitamente definido como `MessageBody`. Para obter mais informações, consulte [Atributos de mensagem do Amazon SNS](sns-message-attributes.md). 1. Selecione **Publish message (Publicar mensagem)**. A mensagem é publicada no tópico e o console abre a página **Details** (Detalhes). ## Para publicar uma mensagem em um tópico usando um AWS SDK 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*. Os exemplos de código a seguir mostram como usar o `Publish`. ------ #### [ .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). Publique uma mensagem em um tópico. ``` using System; using System.Threading.Tasks; using Amazon.SimpleNotificationService; using Amazon.SimpleNotificationService.Model; /// /// This example publishes a message to an Amazon Simple Notification /// Service (Amazon SNS) topic. /// public class PublishToSNSTopic { public static async Task Main() { string topicArn = "arn:aws:sns:us-east-2:000000000000:ExampleSNSTopic"; string messageText = "This is an example message to publish to the ExampleSNSTopic."; IAmazonSimpleNotificationService client = new AmazonSimpleNotificationServiceClient(); await PublishToTopicAsync(client, topicArn, messageText); } /// /// Publishes a message to an Amazon SNS topic. /// /// The initialized client object used to publish /// to the Amazon SNS topic. /// The ARN of the topic. /// The text of the message. public static async Task PublishToTopicAsync( IAmazonSimpleNotificationService client, string topicArn, string messageText) { var request = new PublishRequest { TopicArn = topicArn, Message = messageText, }; var response = await client.PublishAsync(request); Console.WriteLine($"Successfully published message ID: {response.MessageId}"); } } ``` Publique uma mensagem em um tópico com opções de grupo, duplicação e atributo. ``` /// /// Publish messages using user settings. /// /// Async task. public static async Task PublishMessages() { Console.WriteLine("Now we can publish messages."); var keepSendingMessages = true; string? deduplicationId = null; string? toneAttribute = null; while (keepSendingMessages) { Console.WriteLine(); var message = GetUserResponse("Enter a message to publish.", "This is a sample message"); if (_useFifoTopic) { Console.WriteLine("Because you are using a FIFO topic, you must set a message group ID." + "\r\nAll messages within the same group will be received in the order " + "they were published."); Console.WriteLine(); var messageGroupId = GetUserResponse("Enter a message group ID for this message:", "1"); if (!_useContentBasedDeduplication) { Console.WriteLine("Because you are not using content-based deduplication, " + "you must enter a deduplication ID."); Console.WriteLine("Enter a deduplication ID for this message."); deduplicationId = GetUserResponse("Enter a deduplication ID for this message.", "1"); } if (GetYesNoResponse("Add an attribute to this message?")) { Console.WriteLine("Enter a number for an attribute."); for (int i = 0; i < _tones.Length; i++) { Console.WriteLine($"\t{i + 1}. {_tones[i]}"); } var selection = GetUserResponse("", "1"); int.TryParse(selection, out var selectionNumber); if (selectionNumber > 0 && selectionNumber < _tones.Length) { toneAttribute = _tones[selectionNumber - 1]; } } var messageID = await SnsWrapper.PublishToTopicWithAttribute( _topicArn, message, "tone", toneAttribute, deduplicationId, messageGroupId); Console.WriteLine($"Message published with id {messageID}."); } keepSendingMessages = GetYesNoResponse("Send another message?", false); } } ``` Aplique as seleções do usuário à ação de publicação. ``` /// /// Publish a message to a topic with an attribute and optional deduplication and group IDs. /// /// The ARN of the topic. /// The message to publish. /// The optional attribute for the message. /// The optional attribute value for the message. /// The optional deduplication ID for the message. /// The optional group ID for the message. /// The ID of the message published. public async Task PublishToTopicWithAttribute( string topicArn, string message, string? attributeName = null, string? attributeValue = null, string? deduplicationId = null, string? groupId = null) { var publishRequest = new PublishRequest() { TopicArn = topicArn, Message = message, MessageDeduplicationId = deduplicationId, MessageGroupId = groupId }; if (attributeValue != null) { // Add the string attribute if it exists. publishRequest.MessageAttributes = new Dictionary { { attributeName!, new MessageAttributeValue() { StringValue = attributeValue, DataType = "String"} } }; } var publishResponse = await _amazonSNSClient.PublishAsync(publishRequest); return publishResponse.MessageId; } ``` + 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). ``` //! Send a message to an Amazon Simple Notification Service (Amazon SNS) topic. /*! \param message: The message to publish. \param topicARN: The Amazon Resource Name (ARN) for an Amazon SNS topic. \param clientConfiguration: AWS client configuration. \return bool: Function succeeded. */ bool AwsDoc::SNS::publishToTopic(const Aws::String &message, const Aws::String &topicARN, const Aws::Client::ClientConfiguration &clientConfiguration) { Aws::SNS::SNSClient snsClient(clientConfiguration); Aws::SNS::Model::PublishRequest request; request.SetMessage(message); request.SetTopicArn(topicARN); const Aws::SNS::Model::PublishOutcome outcome = snsClient.Publish(request); if (outcome.IsSuccess()) { std::cout << "Message published successfully with id '" << outcome.GetResult().GetMessageId() << "'." << std::endl; } else { std::cerr << "Error while publishing message " << outcome.GetError().GetMessage() << std::endl; } return outcome.IsSuccess(); } ``` Publicar uma mensagem com um atributo. ``` static const Aws::String TONE_ATTRIBUTE("tone"); static const Aws::Vector TONES = {"cheerful", "funny", "serious", "sincere"}; Aws::Client::ClientConfiguration clientConfig; // Optional: Set to the AWS Region (overrides config file). // clientConfig.region = "us-east-1"; Aws::SNS::SNSClient snsClient(clientConfiguration); Aws::SNS::Model::PublishRequest request; request.SetTopicArn(topicARN); Aws::String message = askQuestion("Enter a message text to publish. "); request.SetMessage(message); if (filteringMessages && askYesNoQuestion( "Add an attribute to this message? (y/n) ")) { for (size_t i = 0; i < TONES.size(); ++i) { std::cout << " " << (i + 1) << ". " << TONES[i] << std::endl; } int selection = askQuestionForIntRange( "Enter a number for an attribute. ", 1, static_cast(TONES.size())); Aws::SNS::Model::MessageAttributeValue messageAttributeValue; messageAttributeValue.SetDataType("String"); messageAttributeValue.SetStringValue(TONES[selection - 1]); request.AddMessageAttributes(TONE_ATTRIBUTE, messageAttributeValue); } Aws::SNS::Model::PublishOutcome outcome = snsClient.Publish(request); if (outcome.IsSuccess()) { std::cout << "Your message was successfully published." << std::endl; } else { std::cerr << "Error with TopicsAndQueues::Publish. " << outcome.GetError().GetMessage() << std::endl; cleanUp(topicARN, queueURLS, subscriptionARNS, snsClient, sqsClient); return false; } ``` + 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 *. ------ #### [ CLI ] **AWS CLI** **Exemplo 1: Para publicar uma mensagem em um tópico:** O exemplo `publish` a seguir publica a mensagem específica no tópico do SNS especificado. A mensagem é proveniente de um arquivo de texto, o que permite incluir quebras de linha. ``` aws sns publish \ --topic-arn "arn:aws:sns:us-west-2:123456789012:my-topic" \ --message file://message.txt ``` Conteúdo de `message.txt`: ``` Hello World Second Line ``` Saída: ``` { "MessageId": "123a45b6-7890-12c3-45d6-111122223333" } ``` **Exemplo 2: Para publicar uma mensagem SMS em um número de telefone** O exemplo `publish` a seguir publica a mensagem `Hello world!` no número de telefone `+1-555-555-0100`. ``` aws sns publish \ --message "Hello world!" \ --phone-number +1-555-555-0100 ``` Saída: ``` { "MessageId": "123a45b6-7890-12c3-45d6-333322221111" } ``` + Consulte detalhes da API em [Publish](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/publish.html) na *Referência de comandos da AWS CLI *. ------ #### [ Go ] **SDK para Go V2** 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/gov2/workflows/topics_and_queues#code-examples). ``` import ( "context" "encoding/json" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/service/sns" "github.com/aws/aws-sdk-go-v2/service/sns/types" ) // SnsActions encapsulates the Amazon Simple Notification Service (Amazon SNS) actions // used in the examples. type SnsActions struct { SnsClient *sns.Client } // Publish publishes a message to an Amazon SNS topic. The message is then sent to all // subscribers. When the topic is a FIFO topic, the message must also contain a group ID // and, when ID-based deduplication is used, a deduplication ID. An optional key-value // filter attribute can be specified so that the message can be filtered according to // a filter policy. func (actor SnsActions) Publish(ctx context.Context, topicArn string, message string, groupId string, dedupId string, filterKey string, filterValue string) error { publishInput := sns.PublishInput{TopicArn: aws.String(topicArn), Message: aws.String(message)} if groupId != "" { publishInput.MessageGroupId = aws.String(groupId) } if dedupId != "" { publishInput.MessageDeduplicationId = aws.String(dedupId) } if filterKey != "" && filterValue != "" { publishInput.MessageAttributes = map[string]types.MessageAttributeValue{ filterKey: {DataType: aws.String("String"), StringValue: aws.String(filterValue)}, } } _, err := actor.SnsClient.Publish(ctx, &publishInput) if err != nil { log.Printf("Couldn't publish message to topic %v. Here's why: %v", topicArn, err) } return err } ``` + Consulte detalhes da API em [Publish](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sns#Client.Publish) na *Referência da API AWS SDK para Go *. ------ #### [ 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 PublishTopic { public static void main(String[] args) { final String usage = """ Usage: Where: message - The message text to send. topicArn - The ARN of the topic to publish. """; if (args.length != 2) { System.out.println(usage); System.exit(1); } String message = args[0]; String topicArn = args[1]; SnsClient snsClient = SnsClient.builder() .region(Region.US_EAST_1) .build(); pubTopic(snsClient, message, topicArn); snsClient.close(); } public static void pubTopic(SnsClient snsClient, String message, String topicArn) { try { PublishRequest request = PublishRequest.builder() .message(message) .topicArn(topicArn) .build(); PublishResponse result = snsClient.publish(request); System.out .println(result.messageId() + " Message sent. Status is " + 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 *. ------ #### [ JavaScript ] **SDK para JavaScript (v3)** 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/javascriptv3/example_code/sns#code-examples). Crie o cliente em um módulo separado e exporte-o. ``` import { SNSClient } from "@aws-sdk/client-sns"; // The AWS Region can be provided here using the `region` property. If you leave it blank // the SDK will default to the region set in your AWS config. export const snsClient = new SNSClient({}); ``` Importe o SDK e os módulos do cliente e chame a API. ``` import { PublishCommand } from "@aws-sdk/client-sns"; import { snsClient } from "../libs/snsClient.js"; /** * @param {string | Record} message - The message to send. Can be a plain string or an object * if you are using the `json` `MessageStructure`. * @param {string} topicArn - The ARN of the topic to which you would like to publish. */ export const publish = async ( message = "Hello from SNS!", topicArn = "TOPIC_ARN", ) => { const response = await snsClient.send( new PublishCommand({ Message: message, TopicArn: topicArn, }), ); console.log(response); // { // '$metadata': { // httpStatusCode: 200, // requestId: 'e7f77526-e295-5325-9ee4-281a43ad1f05', // extendedRequestId: undefined, // cfId: undefined, // attempts: 1, // totalRetryDelay: 0 // }, // MessageId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx' // } return response; }; ``` Publique uma mensagem em um tópico com opções de grupo, duplicação e atributo. ``` async publishMessages() { const message = await this.prompter.input({ message: MESSAGES.publishMessagePrompt, }); let groupId; let deduplicationId; let choices; if (this.isFifo) { await this.logger.log(MESSAGES.groupIdNotice); groupId = await this.prompter.input({ message: MESSAGES.groupIdPrompt, }); if (this.autoDedup === false) { await this.logger.log(MESSAGES.deduplicationIdNotice); deduplicationId = await this.prompter.input({ message: MESSAGES.deduplicationIdPrompt, }); } choices = await this.prompter.checkbox({ message: MESSAGES.messageAttributesPrompt, choices: toneChoices, }); } await this.snsClient.send( new PublishCommand({ TopicArn: this.topicArn, Message: message, ...(groupId ? { MessageGroupId: groupId, } : {}), ...(deduplicationId ? { MessageDeduplicationId: deduplicationId, } : {}), ...(choices ? { MessageAttributes: { tone: { DataType: "String.Array", StringValue: JSON.stringify(choices), }, }, } : {}), }), ); const publishAnother = await this.prompter.confirm({ message: MESSAGES.publishAnother, }); if (publishAnother) { await this.publishMessages(); } } ``` + Para obter mais informações, consulte o [Guia do desenvolvedor do AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-publishing-messages.html). + Consulte detalhes da API em [Publish](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/PublishCommand) na *Referência da API AWS SDK para JavaScript *. ------ #### [ 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 pubTopic( topicArnVal: String, messageVal: String, ) { val request = PublishRequest { message = messageVal topicArn = topicArnVal } 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 message to an Amazon SNS topic. * * 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.'; $topic = 'arn:aws:sns:us-east-1:111122223333:MyTopic'; try { $result = $SnSclient->publish([ 'Message' => $message, 'TopicArn' => $topic, ]); 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-subscribing-unsubscribing-topics.html#publish-a-message-to-an-sns-topic). + Consulte detalhes da API em [Publish](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Publish) na *Referência da API AWS SDK para PHP *. ------ #### [ PowerShell ] **Ferramentas para PowerShell V4** **Exemplo 1: Este exemplo mostra a publicação de uma mensagem com uma única MessageAttribute declaração em linha.** ``` Publish-SNSMessage -TopicArn "arn:aws:sns:us-west-2:123456789012:my-topic" -Message "Hello" -MessageAttribute @{'City'=[Amazon.SimpleNotificationService.Model.MessageAttributeValue]@{DataType='String'; StringValue ='AnyCity'}} ``` **Exemplo 2: Este exemplo mostra a publicação de uma mensagem com várias MessageAttributes declaradas com antecedência.** ``` $cityAttributeValue = New-Object Amazon.SimpleNotificationService.Model.MessageAttributeValue $cityAttributeValue.DataType = "String" $cityAttributeValue.StringValue = "AnyCity" $populationAttributeValue = New-Object Amazon.SimpleNotificationService.Model.MessageAttributeValue $populationAttributeValue.DataType = "Number" $populationAttributeValue.StringValue = "1250800" $messageAttributes = New-Object System.Collections.Hashtable $messageAttributes.Add("City", $cityAttributeValue) $messageAttributes.Add("Population", $populationAttributeValue) Publish-SNSMessage -TopicArn "arn:aws:sns:us-west-2:123456789012:my-topic" -Message "Hello" -MessageAttribute $messageAttributes ``` + Consulte detalhes da API em [Publish](https://docs.aws.amazon.com/powershell/v4/reference) na *Referência de cmdlet do Ferramentas da AWS para PowerShell (V4)*. **Ferramentas para PowerShell V5** **Exemplo 1: Este exemplo mostra a publicação de uma mensagem com uma única MessageAttribute declaração em linha.** ``` Publish-SNSMessage -TopicArn "arn:aws:sns:us-west-2:123456789012:my-topic" -Message "Hello" -MessageAttribute @{'City'=[Amazon.SimpleNotificationService.Model.MessageAttributeValue]@{DataType='String'; StringValue ='AnyCity'}} ``` **Exemplo 2: Este exemplo mostra a publicação de uma mensagem com várias MessageAttributes declaradas com antecedência.** ``` $cityAttributeValue = New-Object Amazon.SimpleNotificationService.Model.MessageAttributeValue $cityAttributeValue.DataType = "String" $cityAttributeValue.StringValue = "AnyCity" $populationAttributeValue = New-Object Amazon.SimpleNotificationService.Model.MessageAttributeValue $populationAttributeValue.DataType = "Number" $populationAttributeValue.StringValue = "1250800" $messageAttributes = New-Object System.Collections.Hashtable $messageAttributes.Add("City", $cityAttributeValue) $messageAttributes.Add("Population", $populationAttributeValue) Publish-SNSMessage -TopicArn "arn:aws:sns:us-west-2:123456789012:my-topic" -Message "Hello" -MessageAttribute $messageAttributes ``` + Consulte detalhes da API em [Publish](https://docs.aws.amazon.com/powershell/v5/reference) na *Referência de cmdlet do Ferramentas da AWS para PowerShell (V5)*. ------ #### [ 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). Publique uma mensagem com atributos para que uma assinatura possa filtrar com base em atributos. ``` 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 @staticmethod def publish_message(topic, message, attributes): """ Publishes a message, with attributes, to a topic. Subscriptions can be filtered based on message attributes so that a subscription receives messages only when specified attributes are present. :param topic: The topic to publish to. :param message: The message to publish. :param attributes: The key-value attributes to attach to the message. Values must be either `str` or `bytes`. :return: The ID of the message. """ try: att_dict = {} for key, value in attributes.items(): if isinstance(value, str): att_dict[key] = {"DataType": "String", "StringValue": value} elif isinstance(value, bytes): att_dict[key] = {"DataType": "Binary", "BinaryValue": value} response = topic.publish(Message=message, MessageAttributes=att_dict) message_id = response["MessageId"] logger.info( "Published message with attributes %s to topic %s.", attributes, topic.arn, ) except ClientError: logger.exception("Couldn't publish message to topic %s.", topic.arn) raise else: return message_id ``` Publique uma mensagem que assume diferentes formas com base no protocolo do assinante. ``` 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 @staticmethod def publish_multi_message( topic, subject, default_message, sms_message, email_message ): """ Publishes a multi-format message to a topic. A multi-format message takes different forms based on the protocol of the subscriber. For example, an SMS subscriber might receive a short version of the message while an email subscriber could receive a longer version. :param topic: The topic to publish to. :param subject: The subject of the message. :param default_message: The default version of the message. This version is sent to subscribers that have protocols that are not otherwise specified in the structured message. :param sms_message: The version of the message sent to SMS subscribers. :param email_message: The version of the message sent to email subscribers. :return: The ID of the message. """ try: message = { "default": default_message, "sms": sms_message, "email": email_message, } response = topic.publish( Message=json.dumps(message), Subject=subject, MessageStructure="json" ) message_id = response["MessageId"] logger.info("Published multi-format message to topic %s.", topic.arn) except ClientError: logger.exception("Couldn't publish message to topic %s.", topic.arn) raise else: return message_id ``` ``` class SnsWrapper: """Wrapper class for managing Amazon SNS operations.""" def __init__(self, sns_client: Any) -> None: """ Initialize the SnsWrapper. :param sns_client: A Boto3 Amazon SNS client. """ self.sns_client = sns_client @classmethod def from_client(cls) -> 'SnsWrapper': """ Create an SnsWrapper instance using a default boto3 client. :return: An instance of this class. """ sns_client = boto3.client('sns') return cls(sns_client) def publish_message( self, topic_arn: str, message: str, tone_attribute: Optional[str] = None, deduplication_id: Optional[str] = None, message_group_id: Optional[str] = None ) -> str: """ Publish a message to an SNS topic. :param topic_arn: The ARN of the SNS topic. :param message: The message content to publish. :param tone_attribute: Optional tone attribute for message filtering. :param deduplication_id: Optional deduplication ID for FIFO topics. :param message_group_id: Optional message group ID for FIFO topics. :return: The message ID of the published message. :raises ClientError: If the message publication fails. """ try: publish_args = { 'TopicArn': topic_arn, 'Message': message } # Add message attributes if tone is specified if tone_attribute: publish_args['MessageAttributes'] = { 'tone': { 'DataType': 'String', 'StringValue': tone_attribute } } # Add FIFO-specific parameters if message_group_id: publish_args['MessageGroupId'] = message_group_id if deduplication_id: publish_args['MessageDeduplicationId'] = deduplication_id response = self.sns_client.publish(**publish_args) message_id = response['MessageId'] logger.info(f"Published message to topic {topic_arn} with ID: {message_id}") return message_id except ClientError as e: error_code = e.response.get('Error', {}).get('Code', 'Unknown') logger.error(f"Error publishing message to topic: {error_code} - {e}") raise ``` + 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)*. ------ #### [ Ruby ] **SDK para Ruby** 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/ruby/example_code/sns#code-examples). ``` # Service class for sending messages using Amazon Simple Notification Service (SNS) class SnsMessageSender # Initializes the SnsMessageSender with an SNS client # # @param sns_client [Aws::SNS::Client] The SNS client def initialize(sns_client) @sns_client = sns_client @logger = Logger.new($stdout) end # Sends a message to a specified SNS topic # # @param topic_arn [String] The ARN of the SNS topic # @param message [String] The message to send # @return [Boolean] true if message was successfully sent, false otherwise def send_message(topic_arn, message) @sns_client.publish(topic_arn: topic_arn, message: message) @logger.info("Message sent successfully to #{topic_arn}.") true rescue Aws::SNS::Errors::ServiceError => e @logger.error("Error while sending the message: #{e.message}") false end end # Example usage: if $PROGRAM_NAME == __FILE__ topic_arn = 'SNS_TOPIC_ARN' # Should be replaced with a real topic ARN message = 'MESSAGE' # Should be replaced with the actual message content sns_client = Aws::SNS::Client.new message_sender = SnsMessageSender.new(sns_client) @logger.info('Sending message.') unless message_sender.send_message(topic_arn, message) @logger.error('Message sending failed. Stopping program.') exit 1 end end ``` + Para obter mais informações, consulte o [Guia do desenvolvedor do AWS SDK para Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/sns-example-send-message.html). + Consulte detalhes da API em [Publish](https://docs.aws.amazon.com/goto/SdkForRubyV3/sns-2010-03-31/Publish) na *Referência da API AWS SDK para Ruby *. ------ #### [ Rust ] **SDK for Rust** 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/rustv1/examples/sns#code-examples). ``` async fn subscribe_and_publish( client: &Client, topic_arn: &str, email_address: &str, ) -> Result<(), Error> { println!("Receiving on topic with ARN: `{}`", topic_arn); let rsp = client .subscribe() .topic_arn(topic_arn) .protocol("email") .endpoint(email_address) .send() .await?; println!("Added a subscription: {:?}", rsp); let rsp = client .publish() .topic_arn(topic_arn) .message("hello sns!") .send() .await?; println!("Published message: {:?}", rsp); Ok(()) } ``` + Consulte detalhes da API em [Publish](https://docs.rs/aws-sdk-sns/latest/aws_sdk_sns/client/struct.Client.html#method.publish) na *Referência da API AWS SDK for Rust*. ------ #### [ 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). ``` TRY. oo_result = lo_sns->publish( " oo_result is returned for testing purposes. " iv_topicarn = iv_topic_arn iv_message = iv_message ). MESSAGE 'Message published to SNS topic.' TYPE 'I'. CATCH /aws1/cx_snsnotfoundexception. MESSAGE 'Topic does not exist.' TYPE 'E'. ENDTRY. ``` Publique uma mensagem com atributos para um tópico. ``` TRY. oo_result = lo_sns->publish( " oo_result is returned for testing purposes. " iv_topicarn = iv_topic_arn iv_message = iv_message it_messageattributes = it_msg_attrs ). MESSAGE 'Message with attributes published to SNS topic.' TYPE 'I'. CATCH /aws1/cx_snsnotfoundexception. MESSAGE 'Topic does not exist.' TYPE 'E'. ENDTRY. ``` Publique uma mensagem em vários formatos em um tópico. ``` " Build JSON message structure for multi-format message DATA(lv_json_message) = |\{ "default": "{ iv_default_message }", "sms": "{ iv_sms_message }", "email": "{ iv_email_message }" \}|. TRY. oo_result = lo_sns->publish( " oo_result is returned for testing purposes. " iv_topicarn = iv_topic_arn iv_message = lv_json_message iv_subject = iv_subject iv_messagestructure = 'json' ). MESSAGE 'Multi-format message published to SNS topic.' TYPE 'I'. CATCH /aws1/cx_snsnotfoundexception. MESSAGE 'Topic 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*. ------ #### [ Swift ] **SDK para Swift** 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/swift/example_code/sns#code-examples). ``` import AWSSNS let config = try await SNSClient.SNSClientConfiguration(region: region) let snsClient = SNSClient(config: config) let output = try await snsClient.publish( input: PublishInput( message: message, topicArn: arn ) ) guard let messageId = output.messageId else { print("No message ID received from Amazon SNS.") return } print("Published message with ID \(messageId)") ``` + Consulte detalhes da API em [Publish](https://sdk.amazonaws.com/swift/api/awssns/latest/documentation/awssns/snsclient/publish(input:)) na *Referência de API do AWS SDK para Swift*. ------ # Publicar mensagens grandes com o Amazon SNS e o Amazon S3 Para publicar mensagens grandes do Amazon SNS, você pode usar a [Biblioteca do cliente em versão ampliada para Java do Amazon SNS](https://github.com/awslabs/amazon-sns-java-extended-client-lib/) ou a [Biblioteca do cliente em versão ampliada para Python do Amazon SNS](https://github.com/awslabs/amazon-sns-python-extended-client-lib). Essas bibliotecas são úteis para mensagens maiores do que o máximo atual de 256 KB, até o máximo de 2 GB. As bibliotecas salvam a carga útil real em um bucket do Amazon S3 e publicam a referência do objeto armazenado do Amazon S3 no tópico do Amazon SNS. As filas do Amazon SQS inscritas podem usar a [biblioteca do cliente em versão ampliada do Amazon SQS para Java](https://github.com/awslabs/amazon-sqs-java-extended-client-lib) para cancelar a referência e recuperar cargas úteis do Amazon S3. Outros endpoints, como o Lambda, podem usar a [Payload Offloading Java Common Library for AWS](https://github.com/awslabs/payload-offloading-java-common-lib-for-aws) para cancelar a referência e recuperar a carga útil. **nota** As bibliotecas do cliente em versão ampliada do Amazon SNS são compatíveis com tópicos comuns e FIFO. # Biblioteca do cliente em versão ampliada para Java do Amazon SNS ## Pré-requisitos Veja a seguir os pré-requisitos para usar a [Biblioteca do cliente em versão ampliada para Java do Amazon SNS](https://github.com/awslabs/amazon-sns-java-extended-client-lib): + Um AWS SDK. O exemplo nesta página usa o AWS Java SDK. Para instalar e configurar o SDK, consulte [Configurar o AWS SDK para](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-install.html) Java no Guia *AWS SDK para Java do* desenvolvedor. + E Conta da AWS com as credenciais adequadas. Para criar uma Conta da AWS, navegue até a [página AWS inicial](https://aws.amazon.com/) e escolha **Criar uma AWS conta**. Siga as instruções. Para obter informações sobre credenciais, consulte [Configurar AWS credenciais e região para desenvolvimento no Guia](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-credentials.html) do *AWS SDK para Java desenvolvedor*. + Java 8 ou posterior. + A Biblioteca do cliente em versão ampliada para Java (também disponível no [Maven](https://maven.apache.org/)). ## Configurar o armazenamento de mensagens A biblioteca Amazon SNS Extended Client usa a biblioteca comum Java Payload Offloading AWS para armazenamento e recuperação de mensagens. Você pode configurar as seguintes [opções de armazenamento de mensagens](https://github.com/awslabs/amazon-sns-java-extended-client-lib/blob/main/src/main/java/software/amazon/sns/SNSExtendedClientConfiguration.java) do Amazon S3: + **Limite de tamanhos de mensagens personalizadas**: as mensagens com cargas úteis e atributos que excederem esse tamanho serão automaticamente armazenadas no Amazon S3. + **Sinalizador `alwaysThroughS3`**: defina esse valor como `true` para forçar todas as cargas úteis de mensagens a serem armazenadas no Amazon S3. Por exemplo: ``` SNSExtendedClientConfiguration snsExtendedClientConfiguration = new SNSExtendedClientConfiguration() .withPayloadSupportEnabled(s3Client, BUCKET_NAME).withAlwaysThroughS3(true); ``` + **Chave KMS personalizada**: a chave a ser usada para criptografia do lado do servidor em seu bucket do Amazon S3. + **Nome do bucket**: o nome do bucket do Amazon S3 para armazenar cargas úteis de mensagens. ## Exemplo: publicação de mensagens no Amazon SNS com carga útil armazenada no Amazon S3 O exemplo de código a seguir mostra como: + Criar um tópico de exemplo e uma fila. + Inscrever a fila para receber mensagens do tópico. + Publicar uma mensagem de teste. A carga útil da mensagem é armazenada no Amazon S3 e a referência a ela é publicada. O Amazon SQS Extended Client é usado para receber a mensagem. **SDK para Java 1.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/java/example_code/sns#code-examples). Para publicar uma mensagem grande, use a Amazon SNS Extended Client Library for Java. A mensagem que você envia faz referência a um objeto do Amazon S3 que contém o conteúdo real da mensagem. ``` import com.amazon.sqs.javamessaging.AmazonSQSExtendedClient; import com.amazon.sqs.javamessaging.ExtendedClientConfiguration; import com.amazonaws.regions.Region; import com.amazonaws.regions.Regions; import com.amazonaws.services.s3.AmazonS3; import com.amazonaws.services.s3.AmazonS3ClientBuilder; import com.amazonaws.services.sns.AmazonSNS; import com.amazonaws.services.sns.AmazonSNSClientBuilder; import com.amazonaws.services.sns.model.CreateTopicRequest; import com.amazonaws.services.sns.model.PublishRequest; import com.amazonaws.services.sns.model.SetSubscriptionAttributesRequest; import com.amazonaws.services.sns.util.Topics; import com.amazonaws.services.sqs.AmazonSQS; import com.amazonaws.services.sqs.AmazonSQSClientBuilder; import com.amazonaws.services.sqs.model.CreateQueueRequest; import com.amazonaws.services.sqs.model.ReceiveMessageResult; import software.amazon.sns.AmazonSNSExtendedClient; import software.amazon.sns.SNSExtendedClientConfiguration; public class Example { public static void main(String[] args) { final String BUCKET_NAME = "extended-client-bucket"; final String TOPIC_NAME = "extended-client-topic"; final String QUEUE_NAME = "extended-client-queue"; final Regions region = Regions.DEFAULT_REGION; // Message threshold controls the maximum message size that will be allowed to // be published // through SNS using the extended client. Payload of messages exceeding this // value will be stored in // S3. The default value of this parameter is 256 KB which is the maximum // message size in SNS (and SQS). final int EXTENDED_STORAGE_MESSAGE_SIZE_THRESHOLD = 32; // Initialize SNS, SQS and S3 clients final AmazonSNS snsClient = AmazonSNSClientBuilder.standard().withRegion(region).build(); final AmazonSQS sqsClient = AmazonSQSClientBuilder.standard().withRegion(region).build(); final AmazonS3 s3Client = AmazonS3ClientBuilder.standard().withRegion(region).build(); // Create bucket, topic, queue and subscription s3Client.createBucket(BUCKET_NAME); final String topicArn = snsClient.createTopic( new CreateTopicRequest().withName(TOPIC_NAME)).getTopicArn(); final String queueUrl = sqsClient.createQueue( new CreateQueueRequest().withQueueName(QUEUE_NAME)).getQueueUrl(); final String subscriptionArn = Topics.subscribeQueue( snsClient, sqsClient, topicArn, queueUrl); // To read message content stored in S3 transparently through SQS extended // client, // set the RawMessageDelivery subscription attribute to TRUE final SetSubscriptionAttributesRequest subscriptionAttributesRequest = new SetSubscriptionAttributesRequest(); subscriptionAttributesRequest.setSubscriptionArn(subscriptionArn); subscriptionAttributesRequest.setAttributeName("RawMessageDelivery"); subscriptionAttributesRequest.setAttributeValue("TRUE"); snsClient.setSubscriptionAttributes(subscriptionAttributesRequest); // Initialize SNS extended client // PayloadSizeThreshold triggers message content storage in S3 when the // threshold is exceeded // To store all messages content in S3, use AlwaysThroughS3 flag final SNSExtendedClientConfiguration snsExtendedClientConfiguration = new SNSExtendedClientConfiguration() .withPayloadSupportEnabled(s3Client, BUCKET_NAME) .withPayloadSizeThreshold(EXTENDED_STORAGE_MESSAGE_SIZE_THRESHOLD); final AmazonSNSExtendedClient snsExtendedClient = new AmazonSNSExtendedClient(snsClient, snsExtendedClientConfiguration); // Publish message via SNS with storage in S3 final String message = "This message is stored in S3 as it exceeds the threshold of 32 bytes set above."; snsExtendedClient.publish(topicArn, message); // Initialize SQS extended client final ExtendedClientConfiguration sqsExtendedClientConfiguration = new ExtendedClientConfiguration() .withPayloadSupportEnabled(s3Client, BUCKET_NAME); final AmazonSQSExtendedClient sqsExtendedClient = new AmazonSQSExtendedClient(sqsClient, sqsExtendedClientConfiguration); // Read the message from the queue final ReceiveMessageResult result = sqsExtendedClient.receiveMessage(queueUrl); System.out.println("Received message is " + result.getMessages().get(0).getBody()); } } ``` ## Outros protocolos de endpoint Tanto as bibliotecas do Amazon SNS quanto do Amazon SQS usam a [Payload Offloading Java Common Library for AWS](https://github.com/awslabs/payload-offloading-java-common-lib-for-aws) para armazenar e recuperar cargas úteis de mensagens com o Amazon S3. Qualquer endpoint habilitado para Java (por exemplo, um endpoint HTTPS implementado em Java) pode usar a mesma biblioteca para cancelar a referência ao conteúdo da mensagem. Os endpoints que não podem usar a biblioteca comum Java para descarregamento de carga ainda AWS podem publicar mensagens com cargas armazenadas no Amazon S3. Veja a seguir um exemplo de uma referência do Amazon S3 que é publicada pelo exemplo de código acima: ``` [ "software.amazon.payloadoffloading.PayloadS3Pointer", { "s3BucketName": "extended-client-bucket", "s3Key": "xxxx-xxxxx-xxxxx-xxxxxx" } ] ``` # Biblioteca do cliente em versão ampliada para Python ## Pré-requisitos Veja a seguir os pré-requisitos para usar a [Biblioteca do cliente em versão ampliada para Python do Amazon SNS](https://github.com/awslabs/amazon-sns-python-extended-client-lib): + Um AWS SDK. O exemplo nesta página usa o AWS Python SDK Boto3. Para instalar e configurar o SDK, consulte a documentação do [https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html). + E Conta da AWS com as credenciais adequadas. Para criar uma Conta da AWS, navegue até a [página AWS inicial](https://aws.amazon.com/) e escolha **Criar uma AWS conta**. Siga as instruções. Para obter informações sobre credenciais, consulte [Credenciais](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) no *Guia do desenvolvedor do AWS SDK para Python*. + Python 3.x (ou posterior) e pip. + A Biblioteca do cliente em versão ampliada para Python (também disponível no [PyPI](https://pypi.org/project/amazon-sns-extended-client/)). ## Configurar o armazenamento de mensagens Os atributos abaixo estão disponíveis no Boto3 Amazon [SNS](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns.html#client) Client[,](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns/topic/index.html) Topic [PlatformEndpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns/platformendpoint/index.html)e objetos para configurar as opções de armazenamento de mensagens do Amazon S3. + **`large_payload_support`**: o nome do bucket do Amazon S3 que armazenará mensagens grandes. + **`use_legacy_attribute`**: se `True`, então todas as mensagens publicadas usam o atributo de mensagem reservada legado (`SQSLargePayloadSize`) em vez do atributo de mensagem reservada atual (`ExtendedPayloadSize`). + **`message_size_threshold`**: o limite para armazenar a mensagem no bucket de mensagens grandes. Deve estar entre `0` e `262144`. O padrão é `262144`. + **`always_through_s3`**: se `True`, então todas as mensagens serão armazenadas no Amazon S3. O padrão é `False`. + **`s3_client`**: o objeto `client` do Amazon S3 do Boto3 usado para armazenar objetos no Amazon S3. Use isso se quiser controlar o cliente do Amazon S3 (por exemplo, uma configuração ou credenciais personalizadas do Amazon S3). O padrão será `boto3.client("s3")` na primeira utilização se não tiver sido definido anteriormente. ## Exemplo: publicação de mensagens no Amazon SNS com a carga útil armazenada no Amazon S3 O exemplo de código a seguir mostra como: + Crie um exemplo de tópico do Amazon SNS e uma fila do Amazon SQS. + Anexe a política à fila do Amazon SQS para receber a mensagem do tópico do Amazon SNS. + Inscrever a fila para receber mensagens do tópico. + Publique uma mensagem de teste usando o cliente estendido, o recurso Topic e PlatformEndpoint o recurso do Amazon SNS. + A carga útil da mensagem é armazenada no Amazon S3 e a referência a ela é publicada. + Imprima a mensagem publicada da fila junto com a mensagem original recuperada do Amazon S3. Para publicar uma mensagem grande, use a Biblioteca do cliente em versão ampliada para Python. A mensagem que você envia faz referência a um objeto do Amazon S3 que contém o conteúdo real da mensagem. ``` import boto3 from sns_extended_client import SNSExtendedClientSession from json import loads s3_extended_payload_bucket = "extended-client-bucket-store" # S3 bucket with the given bucket name is a resource which is created and accessible with the given AWS credentials TOPIC_NAME = "---TOPIC-NAME---" QUEUE_NAME = "---QUEUE-NAME---" def allow_sns_to_write_to_sqs(topicarn, queuearn): policy_document = """{{ "Version": "2012-10-17", "Statement":[ {{ "Sid":"MyPolicy", "Effect":"Allow", "Principal" : {{"AWS" : "*"}}, "Action":"SQS:SendMessage", "Resource": "{}", "Condition":{{ "ArnEquals":{{ "aws:SourceArn": "{}" }} }} }} ] }}""".format(queuearn, topicarn) return policy_document def get_msg_from_s3(body,sns_extended_client): """Handy Helper to fetch message from S3""" json_msg = loads(body) s3_object = sns_extended_client.s3_client.get_object( Bucket=json_msg[1].get("s3BucketName"), Key=json_msg[1].get("s3Key") ) msg = s3_object.get("Body").read().decode() return msg def fetch_and_print_from_sqs(sqs, queue_url,sns_extended_client): sqs_msg = sqs.receive_message( QueueUrl=queue_url, AttributeNames=['All'], MessageAttributeNames=['All'], VisibilityTimeout=0, WaitTimeSeconds=0, MaxNumberOfMessages=1 ).get("Messages")[0] message_body = sqs_msg.get("Body") print("Published Message: {}".format(message_body)) print("Message Stored in S3 Bucket is: {}\n".format(get_msg_from_s3(message_body,sns_extended_client))) # Delete the Processed Message sqs.delete_message( QueueUrl=queue_url, ReceiptHandle=sqs_msg['ReceiptHandle'] ) sns_extended_client = boto3.client("sns", region_name="us-east-1") create_topic_response = sns_extended_client.create_topic(Name=TOPIC_NAME) sns_topic_arn = create_topic_response.get("TopicArn") # create and subscribe an sqs queue to the sns client sqs = boto3.client("sqs",region_name="us-east-1") demo_queue_url = sqs.create_queue(QueueName=QUEUE_NAME).get("QueueUrl") sqs_queue_arn = sqs.get_queue_attributes( QueueUrl=demo_queue_url, AttributeNames=["QueueArn"] )["Attributes"].get("QueueArn") # Adding policy to SQS queue such that SNS topic can send msg to SQS queue policy_json = allow_sns_to_write_to_sqs(sns_topic_arn, sqs_queue_arn) response = sqs.set_queue_attributes( QueueUrl = demo_queue_url, Attributes = { 'Policy' : policy_json } ) # Set the RawMessageDelivery subscription attribute to TRUE if you want to use # SQSExtendedClient to help with retrieving msg from S3 sns_extended_client.subscribe(TopicArn=sns_topic_arn, Protocol="sqs", Endpoint=sqs_queue_arn , Attributes={"RawMessageDelivery":"true"} ) sns_extended_client.large_payload_support = s3_extended_payload_bucket # Change default s3_client attribute of sns_extended_client to use 'us-east-1' region sns_extended_client.s3_client = boto3.client("s3", region_name="us-east-1") # Below is the example that all the messages will be sent to the S3 bucket sns_extended_client.always_through_s3 = True sns_extended_client.publish( TopicArn=sns_topic_arn, Message="This message should be published to S3" ) print("\n\nPublished using SNS extended client:") fetch_and_print_from_sqs(sqs, demo_queue_url,sns_extended_client) # Prints message stored in s3 # Below is the example that all the messages larger than 32 bytes will be sent to the S3 bucket print("\nUsing decreased message size threshold:") sns_extended_client.always_through_s3 = False sns_extended_client.message_size_threshold = 32 sns_extended_client.publish( TopicArn=sns_topic_arn, Message="This message should be published to S3 as it exceeds the limit of the 32 bytes", ) fetch_and_print_from_sqs(sqs, demo_queue_url,sns_extended_client) # Prints message stored in s3 # Below is the example to publish message using the SNS.Topic resource sns_extended_client_resource = SNSExtendedClientSession().resource( "sns", region_name="us-east-1" ) topic = sns_extended_client_resource.Topic(sns_topic_arn) topic.large_payload_support = s3_extended_payload_bucket # Change default s3_client attribute of topic to use 'us-east-1' region topic.s3_client = boto3.client("s3", region_name="us-east-1") topic.always_through_s3 = True # Can Set custom S3 Keys to be used to store objects in S3 topic.publish( Message="This message should be published to S3 using the topic resource", MessageAttributes={ "S3Key": { "DataType": "String", "StringValue": "347c11c4-a22c-42e4-a6a2-9b5af5b76587", } }, ) print("\nPublished using Topic Resource:") fetch_and_print_from_sqs(sqs, demo_queue_url,topic) # Below is the example to publish message using the SNS.PlatformEndpoint resource sns_extended_client_resource = SNSExtendedClientSession().resource( "sns", region_name="us-east-1" ) platform_endpoint = sns_extended_client_resource.PlatformEndpoint(sns_topic_arn) platform_endpoint.large_payload_support = s3_extended_payload_bucket # Change default s3_client attribute of platform_endpoint to use 'us-east-1' region platform_endpoint.s3_client = boto3.client("s3", region_name="us-east-1") platform_endpoint.always_through_s3 = True # Can Set custom S3 Keys to be used to store objects in S3 platform_endpoint.publish( Message="This message should be published to S3 using the PlatformEndpoint resource", MessageAttributes={ "S3Key": { "DataType": "String", "StringValue": "247c11c4-a22c-42e4-a6a2-9b5af5b76587", } }, ) print("\nPublished using PlatformEndpoint Resource:") fetch_and_print_from_sqs(sqs, demo_queue_url,platform_endpoint) ``` **Saída** ``` Published using SNS extended client: Published Message: ["software.amazon.payloadoffloading.PayloadS3Pointer", {"s3BucketName": "extended-client-bucket-store", "s3Key": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}] Message Stored in S3 Bucket is: This message should be published to S3 Using decreased message size threshold: Published Message: ["software.amazon.payloadoffloading.PayloadS3Pointer", {"s3BucketName": "extended-client-bucket-store", "s3Key": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}] Message Stored in S3 Bucket is: This message should be published to S3 as it exceeds the limit of the 32 bytes Published using Topic Resource: Published Message: ["software.amazon.payloadoffloading.PayloadS3Pointer", {"s3BucketName": "extended-client-bucket-store", "s3Key": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}] Message Stored in S3 Bucket is: This message should be published to S3 using the topic resource Published using PlatformEndpoint Resource: Published Message: ["software.amazon.payloadoffloading.PayloadS3Pointer", {"s3BucketName": "extended-client-bucket-store", "s3Key": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}] Message Stored in S3 Bucket is: This message should be published to S3 using the PlatformEndpoint resource ``` # Atributos de mensagem do Amazon SNS O Amazon SNS oferece suporte à entrega de atributos de mensagem, o que permite que você forneça itens de metadados estruturados (como time stamps, dados geoespaciais, assinaturas e identificadores) sobre a mensagem. Para assinaturas SQS, no máximo dez atributos de mensagem podem ser enviados quando [Raw Message Delivery](sns-large-payload-raw-message-delivery.md) (Entrega de mensagens brutas) estiver habilitado. Para enviar mais de dez atributos de mensagem, é necessário desabilitar Entrega de mensagens brutas. As mensagens com mais de 10 atributos de mensagem direcionadas para assinaturas do Amazon SQS habilitadas para entrega bruta de mensagens serão descartadas como erros do lado do cliente. Os atributos de mensagem são opcionais e separados do corpo da mensagem, mas são enviados junto com ele. O destinatário pode usar essas informações para decidir como lidar com ela sem ter de primeiro processar o corpo da mensagem. Para obter informações sobre o envio de mensagens com atributos usando o Console de gerenciamento da AWS ou o AWS SDK para Java, consulte o [Para publicar mensagens em tópicos do Amazon SNS usando o Console de gerenciamento da AWS](sns-publishing.md#sns-publishing-messages) tutorial. **nota** Os atributos de mensagens são enviados somente quando a estrutura da mensagem é String, e não JSON. Também é possível usar atributos de mensagem para ajudar a estruturar a mensagem de notificação por push para endpoints móveis. Nesse cenário, os atributos de mensagens são usados somente para ajudar a estruturar a mensagem de notificação por push. Os atributos não são entregues ao endpoint do mesmo modo que são ao enviar mensagens com atributos de mensagem para endpoints do Amazon SQS. Você também pode usar atributos de mensagens para que suas mensagens possam ser filtradas usando políticas de filtro de assinatura. Você pode aplicar as políticas de filtro a inscrições em tópicos. Quando uma política de filtro é aplicada com o escopo de políticas de filtro definido como `MessageAttributes` (padrão), uma assinatura recebe somente aquelas mensagens que têm atributos aceitos pela política. Para obter mais informações, consulte [Filtragem de mensagens do Amazon SNS](sns-message-filtering.md). **nota** Quando atributos de mensagem são usados para filtragem, o valor deve ser uma string JSON válida. Isso garante que a mensagem seja entregue a uma assinatura com a filtragem de atributos de mensagem ativada. ## Validação e itens de atributos de mensagem Cada atributo de mensagem consiste nos seguintes itens: + **Nome**: o nome do atributo de mensagem pode conter os seguintes caracteres: A-Z, a-z, 0-9, sublinhado (\$1), hífen (-) e ponto (.). O nome não deve iniciar ou terminar com um ponto, e nem ter pontos sucessivos. O nome diferencia maiúsculas e minúsculas e deve ser exclusivo entre todos os nomes de atributos para a mensagem. O nome pode ter até 256 caracteres. O nome não pode começar com `AWS.` ou `Amazon.` (ou quaisquer variações em maiúsculas e minúsculas) porque esses prefixos são reservados para uso da Amazon Web Services. + **Tipo**: os tipos de dados de atributo de mensagem compatíveis são `String`, `String.Array`, `Number` e `Binary`. O tipo de dados tem as mesmas restrições no conteúdo que o corpo da mensagem. Para obter mais informações, consulte a seção [Tipos de dados de atributo de mensagem e validação](#SNSMessageAttributes.DataTypes). + **Valor**: o valor do atributo de mensagem especificado pelo usuário. Para tipos de dados de string, o atributo de valor deve ter as mesmas restrições no conteúdo que o corpo da mensagem. No entanto, se o atributo de mensagem for usado para filtragem, o valor deve ser uma string JSON válida para garantir a compatibilidade com as políticas de filtro de assinatura do Amazon SNS. Para obter mais informações, consulte a ação [Publish](https://docs.aws.amazon.com/sns/latest/api/API_Publish.html) na *Referência da API do Amazon Simple Notification Service*. Nome, tipo e valor não podem estar vazios ou nulos. Além disso, o corpo da mensagem não pode estar vazio ou nulo. Todas as partes do atributo da mensagem, incluindo o nome, o tipo e o valor, são incluídas na restrição de tamanho da mensagem, que é de 256 KB. ## Tipos de dados de atributo de mensagem e validação Os tipos de dados de atributo de mensagem identificam como os valores de atributo de mensagem são processados pelo Amazon SNS. Por exemplo, se o tipo for um número, o Amazon SNS validará que é um número. O Amazon SNS é compatível com os seguintes tipos de dados lógicos em todos os endpoints, com exceção daqueles com observação contrária: + **String**: as strings são Unicode com codificação binária UTF-8. Para obter uma lista de valores de código, consulte [http://en.wikipedia. org/wiki/ASCII](http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters)\$1ASCII\$1printable\$1characters. **nota** Valores substitutos não são aceitos nos atributos da mensagem. Por exemplo, usar um valor substituto para representar um emoji apresentará o seguinte erro: `Invalid attribute value was passed in for message attribute`. + **String.Array**: uma matriz, formatada como uma string, que pode conter vários valores. Os valores podem ser strings, números ou as palavras-chave `true`, `false` e `null`. Um String.Array de número ou tipo booliano não precisa de aspas. Vários valores String.Array são separados por vírgulas. Esse tipo de dados não é compatível com AWS Lambda assinaturas. Se você especificar esse tipo de dados para endpoints do Lambda, ele será passado como o tipo de dados `String` na carga útil JSON que o Amazon SNS entrega ao Lambda. + **Number**: números são inteiros positivos ou negativos ou com ponto flutuante. Números têm alcance e precisão suficientes para abranger a maioria dos possíveis valores que números inteiros, flutuantes e duplicados normalmente comportam. Um número pode ter um valor de -109 a 109, com 5 dígitos de precisão após o ponto decimal. Zeros iniciais e finais são cortados. Esse tipo de dados não é compatível com AWS Lambda assinaturas. Se você especificar esse tipo de dados para endpoints do Lambda, ele será passado como o tipo de dados `String` na carga útil JSON que o Amazon SNS entrega ao Lambda. + **Binary**: os atributos de tipo binário podem armazenar qualquer dado binário, por exemplo, dados compactados, dados criptografados ou imagens. ## Atributos de mensagens reservados para notificações móveis por push A tabela a seguir lista os atributos de mensagens reservadas para serviços de notificação móvel por push que você pode usar para estruturar a mensagem de notificação por push: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sns/latest/dg/sns-message-attributes.html) 1 A Apple rejeitará as notificações do Amazon SNS se os atributos das mensagens não atenderem aos requisitos. Para obter detalhes adicionais, consulte [Envio de solicitações de notificação para](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/sending_notification_requests_to_apns) o APNs site de desenvolvedores da Apple. # Agrupamento de mensagens do Amazon SNS em lotes ## O que é o agrupamento de mensagens em lotes? Uma alternativa à publicação de mensagens em tópicos padrão ou FIFO em solicitações individuais da API `Publish` é usar a API `PublishBatch` do Amazon SNS para publicar até 10 mensagens em uma única solicitação de API. O envio de mensagens em lotes pode ajudar a reduzir os custos associados à conexão de aplicações distribuídas ([sistema de mensagens A2A](sns-system-to-system-messaging.md)) ou ao envio de notificações a pessoas ([sistema de mensagens A2P](sns-user-notifications.md)) com o Amazon SNS em um fator de até 10. O Amazon SNS tem cotas que definem quantas mensagens é possível publicar em um tópico por segundo com base na região de operação. Consulte a página [Endpoints e cotas do Amazon SNS](https://docs.aws.amazon.com/general/latest/gr/sns.html) no guia *Referência geral da AWS* para obter mais informações sobre cotas de API. **nota** O tamanho total agregado de todas as mensagens que você envia em uma única solicitação de API `PublishBatch` não pode exceder 262.144 bytes (256 KiB). A API `PublishBatch` isa a mesma ação da API `Publish` para políticas do IAM. ## Como funciona o agrupamento de mensagens em lotes? A publicação de mensagens com a API `PublishBatch` é semelhante à publicação de mensagens com a API `Publish`. A principal diferença é que cada mensagem em uma solicitação da API `PublishBatch` precisa ser atribuída a um ID de lote exclusivo com até 80 caracteres. Dessa maneira, podem ser retornadas respostas individuais da API pelo Amazon SNS para cada mensagem em um lote para confirmar se cada mensagem foi publicada ou se ocorreu uma falha. Para mensagens que estão sendo publicadas em tópicos FIFO, além de incluir a atribuição de um ID de lote exclusivo, ainda é necessário incluir um `MessageDeduplicationID` e `MessageGroupId` para cada mensagem individual. ## Exemplos **Publicação de um lote de 10 mensagens em um tópico padrão** ``` // Imports import software.amazon.awssdk.services.sns.SnsClient; import software.amazon.awssdk.services.sns.model.PublishBatchRequest; import software.amazon.awssdk.services.sns.model.PublishBatchRequestEntry; import software.amazon.awssdk.services.sns.model.PublishBatchResponse; import software.amazon.awssdk.services.sns.model.SnsException; import java.util.List; import java.util.stream.Collectors; import java.util.stream.IntStream; // Code private static final int MAX_BATCH_SIZE = 10; public static void publishBatchToTopic(SnsClient snsClient, String topicArn, int batchSize) { try { // Validate the batch size if (batchSize > MAX_BATCH_SIZE) { throw new IllegalArgumentException("Batch size cannot exceed " + MAX_BATCH_SIZE); } // Create the batch entries List entries = IntStream.range(0, batchSize) .mapToObj(i -> PublishBatchRequestEntry.builder() .id("id" + i) .message("message" + i) .build()) .collect(Collectors.toList()); // Build the batch request PublishBatchRequest request = PublishBatchRequest.builder() .topicArn(topicArn) .publishBatchRequestEntries(entries) .build(); // Publish the batch request PublishBatchResponse response = snsClient.publishBatch(request); // Handle successful messages response.successful().forEach(success -> { System.out.println("Successful Batch Id: " + success.id()); System.out.println("Message Id: " + success.messageId()); }); // Handle failed messages response.failed().forEach(failure -> { System.err.println("Failed Batch Id: " + failure.id()); System.err.println("Error Code: " + failure.code()); System.err.println("Sender Fault: " + failure.senderFault()); System.err.println("Error Message: " + failure.message()); }); } catch (SnsException e) { // Log and handle exceptions System.err.println("SNS Exception: " + e.awsErrorDetails().errorMessage()); } catch (IllegalArgumentException e) { System.err.println("Validation Error: " + e.getMessage()); } } ``` **Publicação de um lote de 10 mensagens em um tópico FIFO** ``` // Imports import software.amazon.awssdk.services.sns.SnsClient; import software.amazon.awssdk.services.sns.model.PublishBatchRequest; import software.amazon.awssdk.services.sns.model.PublishBatchRequestEntry; import software.amazon.awssdk.services.sns.model.PublishBatchResponse; import software.amazon.awssdk.services.sns.model.BatchResultErrorEntry; import software.amazon.awssdk.services.sns.model.SnsException; import java.util.List; import java.util.stream.Collectors; import java.util.stream.IntStream; // Code private static final int MAX_BATCH_SIZE = 10; public static void publishBatchToFifoTopic(SnsClient snsClient, String topicArn) { try { // Create the batch entries to send List entries = IntStream.range(0, MAX_BATCH_SIZE) .mapToObj(i -> PublishBatchRequestEntry.builder() .id("id" + i) .message("message" + i) .messageGroupId("groupId") .messageDeduplicationId("deduplicationId" + i) .build()) .collect(Collectors.toList()); // Create the batch request PublishBatchRequest request = PublishBatchRequest.builder() .topicArn(topicArn) .publishBatchRequestEntries(entries) .build(); // Publish the batch request PublishBatchResponse response = snsClient.publishBatch(request); // Handle the successfully sent messages response.successful().forEach(success -> { System.out.println("Batch Id for successful message: " + success.id()); System.out.println("Message Id for successful message: " + success.messageId()); System.out.println("Sequence Number for successful message: " + success.sequenceNumber()); }); // Handle the failed messages response.failed().forEach(failure -> { System.err.println("Batch Id for failed message: " + failure.id()); System.err.println("Error Code for failed message: " + failure.code()); System.err.println("Sender Fault for failed message: " + failure.senderFault()); System.err.println("Failure Message for failed message: " + failure.message()); }); } catch (SnsException e) { // Handle any exceptions from the request System.err.println("SNS Exception: " + e.awsErrorDetails().errorMessage()); } } ```