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á.
# Habilitar o buffer no lado do cliente e o agrupamento de solicitações em lote com o Amazon SQS
O [AWS SDK para Java](https://aws.amazon.com/sdkforjava/) inclui o `AmazonSQSBufferedAsyncClient`, que acessa o Amazon SQS. Esse cliente permite um simples agrupamento em lote de solicitações usando o buffer do lado do cliente. Chamadas feitas do cliente são armazenadas primeiramente em buffer, depois enviadas como uma solicitação em lote para o Amazon SQS.
O armazenamento em buffer no lado do cliente permite que até 10 solicitações sejam armazenadas em buffer e enviadas como uma solicitação em lote, diminuindo o custo de uso do Amazon SQS e reduzindo o número de solicitações enviadas. O `AmazonSQSBufferedAsyncClient` armazena tanto as chamadas síncronas quanto as assíncronas em buffer. Solicitações em lote e suporte para [sondagem longa](sqs-short-and-long-polling.md) também podem ajudar a aumentar a taxa de transferência. Para obter mais informações, consulte [Aumento do throughput usando escalabilidade horizontal e processamento de ações em lote com o Amazon SQS](sqs-throughput-horizontal-scaling-and-batching.md).
como o `AmazonSQSBufferedAsyncClient` implementa a mesma interface que o `AmazonSQSAsyncClient`, migrar de `AmazonSQSAsyncClient` para `AmazonSQSBufferedAsyncClient` normalmente requer apenas pequenas mudanças no seu código existente.
**nota**
Atualmente, o cliente assíncrono no buffer do Amazon SQS não oferece suporte a filas FIFO.
## Usando a Amazon SQSBuffered AsyncClient
Antes de começar, conclua as etapas em [Configurar o Amazon SQS](sqs-setting-up.md).
### AWS SDK para Java 1.x
Para o AWS SDK for Java 1.x, você pode criar um `AmazonSQSBufferedAsyncClient` novo com base no exemplo a seguir:
```
// Create the basic Amazon SQS async client
final AmazonSQSAsync sqsAsync = new AmazonSQSAsyncClient();
// Create the buffered client
final AmazonSQSAsync bufferedSqs = new AmazonSQSBufferedAsyncClient(sqsAsync);
```
Depois de criar o novo `AmazonSQSBufferedAsyncClient`, você pode usá-lo para enviar várias solicitações ao Amazon SQS (da mesma forma que faria com o `AmazonSQSAsyncClient`), por exemplo:
```
final CreateQueueRequest createRequest = new CreateQueueRequest().withQueueName("MyQueue");
final CreateQueueResult res = bufferedSqs.createQueue(createRequest);
final SendMessageRequest request = new SendMessageRequest();
final String body = "Your message text" + System.currentTimeMillis();
request.setMessageBody( body );
request.setQueueUrl(res.getQueueUrl());
final Future sendResult = bufferedSqs.sendMessageAsync(request);
final ReceiveMessageRequest receiveRq = new ReceiveMessageRequest()
.withMaxNumberOfMessages(1)
.withQueueUrl(queueUrl);
final ReceiveMessageResult rx = bufferedSqs.receiveMessage(receiveRq);
```
### Configurando a Amazon SQSBuffered AsyncClient
O `AmazonSQSBufferedAsyncClient` é pré-configurado com configurações que funcionarão para a maioria dos casos de uso. Você pode configurar ainda mais o `AmazonSQSBufferedAsyncClient`, por exemplo:
1. Crie uma instância da classe `QueueBufferConfig` com os parâmetros de configuração necessários.
1. Informe a instância para o construtor `AmazonSQSBufferedAsyncClient`.
```
// Create the basic Amazon SQS async client
final AmazonSQSAsync sqsAsync = new AmazonSQSAsyncClient();
final QueueBufferConfig config = new QueueBufferConfig()
.withMaxInflightReceiveBatches(5)
.withMaxDoneReceiveBatches(15);
// Create the buffered client
final AmazonSQSAsync bufferedSqs = new AmazonSQSBufferedAsyncClient(sqsAsync, config);
```
**QueueBufferConfig parâmetros de configuração**
| Parâmetro | Valor padrão | Description |
| --- | --- | --- |
| longPoll | true | Quando `longPoll` está definido como `true`, `AmazonSQSBufferedAsyncClient` tenta usar a sondagem longa ao consumir mensagens. |
| longPollWaitTimeoutSeconds | 20 s | A quantidade máxima de tempo, em segundos, em que uma chamada `ReceiveMessage` é bloqueada no servidor aguardando as mensagens aparecerem na fila antes de retornar com um resultado de recebimento vazio. Quando a sondagem longa está desativada, essa configuração não tem efeito. |
| maxBatchOpenMs | 200ms | A quantidade máxima de tempo (em milissegundos) que uma chamada de saída aguarda outras chamadas com as quais ela coloca mensagens do mesmo tipo em lote. Quanto maior for a configuração, menos lotes serão necessários para executar a mesma quantidade de trabalho (no entanto, a primeira chamada em um lote deve passar mais tempo em espera). Quando esse parâmetro é definido como `0`, as solicitações enviadas não aguardam outras solicitações, desativando efetivamente o processamento em lotes. |
| maxBatchSize | 10 solicitações por lote | O número máximo de mensagens que são armazenadas em lote em uma única solicitação. Quanto maior a configuração, menos lotes serão necessários para executar o mesmo número de solicitações. Dez solicitações por lote é o valor máximo permitido para o Amazon SQS. |
| maxBatchSizeBytes | 1 MiB | O tamanho máximo de um lote de mensagens, em bytes, que o cliente tenta enviar ao Amazon SQS. 1 MiB é o valor máximo permitido para o Amazon SQS. |
| maxDoneReceiveBatches | 10 lotes | O número máximo de lotes de recebimento que `AmazonSQSBufferedAsyncClient` pré-busca e armazena no lado do cliente. Quanto maior for a configuração, mais solicitações de recebimento poderão ser atendidas sem a necessidade de fazer uma chamada ao Amazon SQS (no entanto, quanto mais mensagens forem buscadas previamente, mais tempo elas permanecerão no buffer, fazendo com que o tempo limite de visibilidade expire). `0` indica que toda a pré-busca de mensagens está desabilitada e as mensagens são consumidas apenas sob demanda. |
| maxInflightOutboundBatches | 5 lotes | O número máximo de lotes de saída ativos que podem ser processados ao mesmo tempo. Quanto maior for a configuração, mais rapidamente os lotes de saída poderão ser enviados (sujeito a outras cotas, como CPU ou largura de banda) e mais threads serão consumidos pelo `AmazonSQSBufferedAsyncClient`. |
| maxInflightReceiveBatches | 10 lotes | O número máximo de lotes de recebimento ativos que podem ser processados ao mesmo tempo. Quanto maior for a configuração, mais mensagens serão recebidas (sujeito a outras cotas, como CPU ou largura de banda) e mais threads serão consumidos pelo `AmazonSQSBufferedAsyncClient`. `0` indica que toda a pré-busca de mensagens está desabilitada e as mensagens são consumidas apenas sob demanda. |
| visibilityTimeoutSeconds | -1 | Quando esse parâmetro é definido como um valor positivo e diferente de zero, o tempo limite de visibilidade definido aqui substitui o tempo limite de visibilidade definido na fila a partir da qual as mensagens são consumidas. `-1` indica que a configuração padrão foi selecionada para a fila. Não é possível configurar o tempo limite de visibilidade para `0`. |
### AWS SDK para Java 2.x
Para o AWS SDK for Java 2.x, você pode criar um `SqsAsyncBatchManager` novo com base no exemplo a seguir:
```
// Create the basic Sqs Async Client
SqsAsyncClient sqs = SqsAsyncClient.builder()
.region(Region.US_EAST_1)
.build();
// Create the batch manager
SqsAsyncBatchManager sqsAsyncBatchManager = sqs.batchManager();
```
Depois de criar o novo `SqsAsyncBatchManager`, você pode usá-lo para enviar várias solicitações ao Amazon SQS (da mesma forma que faria com o `SqsAsyncClient`), por exemplo:
```
final String queueName = "MyAsyncBufferedQueue" + UUID.randomUUID();
final CreateQueueRequest request = CreateQueueRequest.builder().queueName(queueName).build();
final String queueUrl = sqs.createQueue(request).join().queueUrl();
System.out.println("Queue created: " + queueUrl);
// Send messages
CompletableFuture sendMessageFuture;
for (int i = 0; i < 10; i++) {
final int index = i;
sendMessageFuture = sqsAsyncBatchManager.sendMessage(
r -> r.messageBody("Message " + index).queueUrl(queueUrl));
SendMessageResponse response= sendMessageFuture.join();
System.out.println("Message " + response.messageId() + " sent!");
}
// Receive messages with customized configurations
CompletableFuture receiveResponseFuture = customizedBatchManager.receiveMessage(
r -> r.queueUrl(queueUrl)
.waitTimeSeconds(10)
.visibilityTimeout(20)
.maxNumberOfMessages(10)
);
System.out.println("You have received " + receiveResponseFuture.join().messages().size() + " messages in total.");
// Delete messages
DeleteQueueRequest deleteQueueRequest = DeleteQueueRequest.builder().queueUrl(queueUrl).build();
int code = sqs.deleteQueue(deleteQueueRequest).join().sdkHttpResponse().statusCode();
System.out.println("Queue is deleted, with statusCode " + code);
```
### Configurando SqsAsyncBatchManager
O `SqsAsyncBatchManager` é pré-configurado com configurações que funcionarão para a maioria dos casos de uso. Você pode configurar ainda mais o `SqsAsyncBatchManager`, por exemplo:
Como criar configurações personalizadas usando o `SqsAsyncBatchManager.Builder`:
```
SqsAsyncBatchManager customizedBatchManager = SqsAsyncBatchManager.builder()
.client(sqs)
.scheduledExecutor(Executors.newScheduledThreadPool(5))
.overrideConfiguration(b -> b
.maxBatchSize(10)
.sendRequestFrequency(Duration.ofMillis(200))
.receiveMessageMinWaitDuration(Duration.ofSeconds(10))
.receiveMessageVisibilityTimeout(Duration.ofSeconds(20))
.receiveMessageAttributeNames(Collections.singletonList("*"))
.receiveMessageSystemAttributeNames(Collections.singletonList(MessageSystemAttributeName.ALL)))
.build();
```
**Parâmetros do `BatchOverrideConfiguration`**
| Parâmetro | Valor padrão | Description |
| --- | --- | --- |
| maxBatchSize | 10 solicitações por lote | O número máximo de mensagens que são armazenadas em lote em uma única solicitação. Quanto maior a configuração, menos lotes serão necessários para executar o mesmo número de solicitações. O valor máximo permitido para o Amazon SQS é de 10 solicitações por lote. |
| sendRequestFrequency | 200ms | A quantidade máxima de tempo (em milissegundos) que uma chamada de saída aguarda outras chamadas com as quais ela coloca mensagens do mesmo tipo em lote. Quanto maior for a configuração, menos lotes serão necessários para executar a mesma quantidade de trabalho (no entanto, a primeira chamada em um lote deve passar mais tempo em espera). Quando esse parâmetro é definido como `0`, as solicitações enviadas não aguardam outras solicitações, desativando efetivamente o processamento em lotes. |
| receiveMessageVisibilityTimeout | -1 | Quando esse parâmetro é definido como um valor positivo e diferente de zero, o tempo limite de visibilidade definido aqui substitui o tempo limite de visibilidade definido na fila a partir da qual as mensagens são consumidas. `1` indica que a configuração padrão foi selecionada para a fila. Não é possível configurar o tempo limite de visibilidade para `0`. |
| receiveMessageMinWaitDuration | 50 ms | O tempo mínimo (em milissegundos) que uma chamada de `receiveMessage` aguardará para que as mensagens disponíveis sejam buscadas. Quanto maior a configuração, menos lotes serão necessários para executar o mesmo número de solicitações. |