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

# Biblioteca do cliente em versão ampliada para Java do Amazon SNS
<a name="extended-client-library-java"></a>

## Pré-requisitos
<a name="prereqs-sns-extended-client-library"></a>

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 name="large-message-configure-storage"></a>

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
<a name="example-s3-large-payloads"></a>

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
<a name="large-payloads-other-protocols"></a>

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"
  }
]
```