

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á.

# Agrupamento de mensagens do Amazon SNS em lotes
<a name="sns-batch-api-actions"></a>

## O que é o agrupamento de mensagens em lotes?
<a name="what-is-message-batching"></a>

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 name="message-batching-how-it-works"></a>

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
<a name="message-batching-examples"></a>

**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<PublishBatchRequestEntry> 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<PublishBatchRequestEntry> 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());
    }
}
```