Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Abilitazione del buffering lato client e del batching delle richieste con Amazon SQS
[AWS SDK per Java](https://aws.amazon.com/sdkforjava/) include `AmazonSQSBufferedAsyncClient` che accede ad Amazon SQS. Questo client consente un semplice raggruppamento delle richieste utilizzando il buffering lato client. Le chiamate effettuate dal client vengono prima memorizzate nel buffer e quindi inviate come richiesta batch ad Amazon SQS.
Il buffering lato client consente di memorizzare e inviare fino a 10 richieste in batch, riducendo il costo di utilizzo di Amazon SQS e il numero di richieste inviate. `AmazonSQSBufferedAsyncClient` effettua il buffering delle chiamate sincrone e asincrone. Le richieste in batch e il supporto per il [polling lungo](sqs-short-and-long-polling.md) possono inoltre contribuire ad aumentare il throughput. Per ulteriori informazioni, consulta [Aumento del throughput utilizzando la scalabilità orizzontale e l'action batching con Amazon SQS](sqs-throughput-horizontal-scaling-and-batching.md).
Poiché `AmazonSQSBufferedAsyncClient` implementa la stessa interfaccia di `AmazonSQSAsyncClient`, la migrazione da `AmazonSQSAsyncClient` a `AmazonSQSBufferedAsyncClient` di solito richiede solo modifiche minime al codice esistente.
**Nota**
L'Amazon SQS Buffered Asynchronous Client attualmente non supporta le code FIFO.
## Usare Amazon SQSBuffered AsyncClient
Prima di iniziare, completa i passaggi descritti in [Configurazione di Amazon SQS](sqs-setting-up.md).
### AWS SDK per Java 1.x
Per AWS SDK for Java 1.x, puoi crearne uno `AmazonSQSBufferedAsyncClient` nuovo basato sul seguente esempio:
```
// Create the basic Amazon SQS async client
final AmazonSQSAsync sqsAsync = new AmazonSQSAsyncClient();
// Create the buffered client
final AmazonSQSAsync bufferedSqs = new AmazonSQSBufferedAsyncClient(sqsAsync);
```
Una volta creato il nuovo `AmazonSQSBufferedAsyncClient`, è possibile utilizzarlo per l'invio di più richieste ad Amazon SQS; (proprio come con `AmazonSQSAsyncClient`), ad esempio:
```
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);
```
### Configurazione di Amazon SQSBuffered AsyncClient
`AmazonSQSBufferedAsyncClient` è preconfigurato con impostazioni che funzionano per la maggior parte dei casi d'uso. È possibile configurare ulteriormente `AmazonSQSBufferedAsyncClient`, ad esempio:
1. Crea un'istanza della classe `QueueBufferConfig` con i parametri di configurazione obbligatori.
1. Fornisci l'istanza al costruttore `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 parametri di configurazione**
| Parametro | Valore predefinito | Description |
| --- | --- | --- |
| longPoll | true | Quando `longPoll` è impostato su `true`, `AmazonSQSBufferedAsyncClient` tenta di utilizzare il polling lungo durante l'utilizzo dei messaggi. |
| longPollWaitTimeoutSeconds | 20 s | Il tempo massimo, in secondi, che una chiamata di `ReceiveMessage` si blocca sul server in attesa che i messaggi compaiano nella coda prima di restituire un risultato di ricezione vuoto. Questa impostazione non ha alcun effetto se il polling lungo è disattivato. |
| maxBatchOpenMs | 200 ms | Il tempo massimo, in millisecondi, che una chiamata in uscita attende altre chiamate dello stesso tipo con cui raggrupparsi. Maggiore è l'impostazione, minore è il numero di batch necessari per eseguire la stessa quantità di lavoro (tuttavia, la prima chiamata in un batch deve dedicare più tempo all'attesa). Quando questo parametro è impostato su `0`, le richieste inviate non attendono altre richieste, disabilitando effettivamente il batching. |
| maxBatchSize | 10 richieste per batch | Il numero massimo di messaggi raggruppati in una singola richiesta. Maggiore è l'impostazione, minore è il numero di batch che sono necessari per eseguire la stessa quantità di richieste. 10 richieste per batch è il valore massimo consentito per Amazon SQS. |
| maxBatchSizeBytes | 1 MiB | Le dimensioni massime del batch di un messaggio, in byte, che il client tenta di inviare ad Amazon SQS . 1 MiB è il valore massimo consentito per Amazon SQS. |
| maxDoneReceiveBatches | 10 batch | Il numero massimo di pre-fetching e archiviazioni di batch `AmazonSQSBufferedAsyncClient` sul lato client. Maggiore è l'impostazione, più richieste di ricezione possono essere soddisfatte senza la necessità di effettuare una chiamata ad Amazon SQS (tuttavia, più messaggi sono pre-recuperati, più tempo rimangono nel buffer, il che significa che il loro timeout visibilità scade). `0`indica che il precaricamento di tutti i messaggi è disabilitato e che i messaggi vengono consumati solo su richiesta. |
| maxInflightOutboundBatches | 5 batch | Il numero massimo di batch in uscita attivi che possono essere elaborati contemporaneamente. Maggiore è l'impostazione, più rapidamente possono essere inviati i batch in uscita (in base alle altre quote, ad esempio CPU o larghezza di banda) e più thread possono essere utilizzati da `AmazonSQSBufferedAsyncClient`. |
| maxInflightReceiveBatches | 10 batch | Il numero massimo di batch di ricezione attivi che possono essere elaborati contemporaneamente. Maggiore è l'impostazione e più messaggi possono essere ricevuti (in base alle quote, ad esempio CPU o larghezza di banda) e più thread possono essere utilizzati da `AmazonSQSBufferedAsyncClient`. `0`indica che la prelettura di tutti i messaggi è disabilitata e che i messaggi vengono consumati solo su richiesta. |
| visibilityTimeoutSeconds | -1 | Quando questo parametro è impostato su un valore diverso da zero, questo timeout visibilità sostituisce il timeout visibilità impostato sulla coda dalla quale vengono utilizzati i messaggi. `-1` indica che per la coda è selezionata l'impostazione predefinita. Non è possibile impostare il timeout visibilità su `0`. |
### AWS SDK per Java 2.x
Per AWS SDK for Java 2.x, puoi crearne uno `SqsAsyncBatchManager` nuovo basato sul seguente esempio:
```
// Create the basic Sqs Async Client
SqsAsyncClient sqs = SqsAsyncClient.builder()
.region(Region.US_EAST_1)
.build();
// Create the batch manager
SqsAsyncBatchManager sqsAsyncBatchManager = sqs.batchManager();
```
Una volta creato il nuovo `SqsAsyncBatchManager`, è possibile utilizzarlo per l'invio di più richieste ad Amazon SQS; (proprio come con `SqsAsyncClient`), ad esempio:
```
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);
```
### Configurazione SqsAsyncBatchManager
`SqsAsyncBatchManager` è preconfigurato con impostazioni che funzionano per la maggior parte dei casi d'uso. È possibile configurare ulteriormente `SqsAsyncBatchManager`, ad esempio:
Creazione di una configurazione personalizzata tramite`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();
```
**Parametri di `BatchOverrideConfiguration`**
| Parametro | Valore predefinito | Description |
| --- | --- | --- |
| maxBatchSize | 10 richieste per batch | Il numero massimo di messaggi raggruppati in una singola richiesta. Maggiore è l'impostazione, minore è il numero di batch che sono necessari per eseguire la stessa quantità di richieste. Il valore massimo consentito per Amazon SQS è di 10 richieste per batch. |
| sendRequestFrequency | 200 ms | Il tempo massimo, in millisecondi, che una chiamata in uscita attende altre chiamate dello stesso tipo con cui raggrupparsi. Maggiore è l'impostazione, minore è il numero di batch necessari per eseguire la stessa quantità di lavoro (tuttavia, la prima chiamata in un batch deve dedicare più tempo all'attesa). Quando questo parametro è impostato su `0`, le richieste inviate non attendono altre richieste, disabilitando effettivamente il batching. |
| receiveMessageVisibilityTimeout | -1 | Quando questo parametro è impostato su un valore diverso da zero, questo timeout visibilità sostituisce il timeout visibilità impostato sulla coda dalla quale vengono utilizzati i messaggi. `1` indica che per la coda è selezionata l'impostazione predefinita. Non è possibile impostare il timeout visibilità su `0`. |
| receiveMessageMinWaitDuration | 50 ms | La quantità minima di tempo (in millisecondi) di attesa di una `receiveMessage` chiamata prima che i messaggi disponibili vengano recuperati. Più alta è l'impostazione, minore è il numero di batch necessari per eseguire lo stesso numero di richieste. |