Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Activation de la mise en mémoire tampon côté client et du traitement par lots des demandes avec Amazon SQS
Le kit [AWS SDK pour Java](https://aws.amazon.com/sdkforjava/) inclut `AmazonSQSBufferedAsyncClient` qui accède à Amazon SQS. Ce client permet un traitement simple par lots de demandes à l'aide de la mise en mémoire tampon côté client. Les appels passés depuis le client sont d'abord mis en mémoire tampon, puis envoyés sous forme de demande groupée à Amazon SQS.
La mise en tampon côté client autorise la mise en tampon et l'envoi en tant que demande par lots de 10 requêtes au maximum, ce qui réduit les coûts d'utilisation d'Amazon SQS et le nombre de requêtes envoyées. `AmazonSQSBufferedAsyncClient` met en tampon les appels synchrones et asynchrones. Les demandes par lots et la prise en charge de l'[attente active de longue durée](sqs-short-and-long-polling.md) peuvent également permettre d'augmenter le débit. Pour de plus amples informations, veuillez consulter [Augmenter le débit grâce à la mise à l'échelle horizontale et au traitement par lots d'actions avec Amazon SQS](sqs-throughput-horizontal-scaling-and-batching.md).
Dans la mesure où `AmazonSQSBufferedAsyncClient` implémente la même interface qu'`AmazonSQSAsyncClient`, la migration d'`AmazonSQSAsyncClient` vers `AmazonSQSBufferedAsyncClient` requiert généralement très peu de changements du code existant.
**Note**
Le client asynchrone en mémoire tampon Amazon SQS ne prend actuellement pas en charge les files d'attente FIFO.
## Utilisation d'Amazon SQSBuffered AsyncClient
Avant de commencer, complétez les étapes détaillées dans [Configuration d'Amazon SQS](sqs-setting-up.md).
### AWS SDK pour Java 1.x
Pour le AWS SDK for Java 1.x, vous pouvez en créer un `AmazonSQSBufferedAsyncClient` nouveau en vous basant sur l'exemple suivant :
```
// Create the basic Amazon SQS async client
final AmazonSQSAsync sqsAsync = new AmazonSQSAsyncClient();
// Create the buffered client
final AmazonSQSAsync bufferedSqs = new AmazonSQSBufferedAsyncClient(sqsAsync);
```
Après avoir créé le nouveau `AmazonSQSBufferedAsyncClient`, utilisez-le pour envoyer plusieurs demandes à Amazon SQS (comme avec `AmazonSQSAsyncClient`), par exemple :
```
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);
```
### Configuration d'Amazon SQSBuffered AsyncClient
`AmazonSQSBufferedAsyncClient` est préconfiguré avec des paramètres qui fonctionnent dans la plupart des cas d'utilisation. Vous pouvez configurer davantage `AmazonSQSBufferedAsyncClient`, par exemple :
1. Créez une instance de la classe `QueueBufferConfig` avec les paramètres de configuration requis.
1. Fournissez l'instance au constructeur `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 paramètres de configuration**
| Paramètre | Valeur par défaut | Description |
| --- | --- | --- |
| longPoll | true | Lorsque `longPoll` est défini sur `true`, `AmazonSQSBufferedAsyncClient` tente d'utiliser l'attente active de longue durée lors de la consommation des messages. |
| longPollWaitTimeoutSeconds | 20 s | Durée maximale, en secondes, pendant laquelle un `ReceiveMessage` reste sur le serveur en attendant l'apparition de messages dans la file d'attente avant de renvoyer un résultat de réception vide. Ce paramètre n'a pas d'impact lorsque l'attente active de longue durée est désactivée. |
| maxBatchOpenMs | 200 ms | Durée maximale, en millisecondes, pendant laquelle un appel sortant attend d'autres appels du même type pour le traitement par lots. Plus le paramètre est élevé, moins il faut de lots pour effectuer la même quantité de travail (toutefois, le premier appel d'un lot doit passer plus de temps à attendre). Lorsque ce paramètre est défini sur `0`, les requêtes envoyées n'attendent pas d'autres requêtes, ce qui a pour effet de désactiver le traitement par lots. |
| maxBatchSize | 10 requêtes par lot | Nombre maximal de messages traités dans un même lot dans le cadre d'une seule requête. Plus ce paramètre est élevé, moins le nombre de lots requis pour effectuer le même nombre de requêtes est élevé. 10 demandes par lots est la valeur maximale autorisée pour Amazon SQS. |
| maxBatchSizeBytes | 1 MiB | Taille maximale d'un lot de messages, en octets, que le client essaie d'envoyer à Amazon SQS. 1 MiB est la valeur maximale autorisée pour Amazon SQS. |
| maxDoneReceiveBatches | 10 lots | Nombre maximal de lots de réception récupérés au préalable par `AmazonSQSBufferedAsyncClient` et stockés côté client. Plus le paramètre est élevé, plus il est possible de satisfaire un grand nombre de demandes sans devoir appeler Amazon SQS (toutefois, plus le nombre de messages récupérés au préalable est important, plus ils restent longtemps dans la mémoire tampon, ce qui entraîne l'expiration de leur délai de visibilité). `0`indique que la prélecture des messages est désactivée et que les messages sont consommés uniquement à la demande. |
| maxInflightOutboundBatches | 5 lots | Nombre maximal de lots sortants actifs pouvant être traités en même temps. Plus ce paramètre est élevé, plus les lots sortants peuvent être envoyés rapidement (sous réserve d'autres quotas, tels que l'UC ou la bande passante) et plus le nombre de threads consommés par `AmazonSQSBufferedAsyncClient` est important. |
| maxInflightReceiveBatches | 10 lots | Nombre maximum de lots de réception actifs pouvant être traités en même temps. Plus ce paramètre est élevé, plus le nombre de messages susceptibles d'être reçus est important (sous réserve d'autres quotas, tels que l'UC ou la bande passante) et plus le nombre de threads consommés par `AmazonSQSBufferedAsyncClient` est important. `0`indique que la prélecture des messages est désactivée et que les messages sont consommés uniquement à la demande. |
| visibilityTimeoutSeconds | -1 | Lorsqu'une valeur positive autre que zéro a été définie pour ce paramètre, le délai de visibilité définit ici prévaut sur celui de la file d'attente à partir de laquelle les messages sont consommés. `-1` indique que le paramètre par défaut est sélectionné pour la file d'attente. Vous ne pouvez pas définir de délai de visibilité sur `0`. |
### AWS SDK pour Java 2.x
Pour le AWS SDK for Java 2.x, vous pouvez en créer un `SqsAsyncBatchManager` nouveau en vous basant sur l'exemple suivant :
```
// Create the basic Sqs Async Client
SqsAsyncClient sqs = SqsAsyncClient.builder()
.region(Region.US_EAST_1)
.build();
// Create the batch manager
SqsAsyncBatchManager sqsAsyncBatchManager = sqs.batchManager();
```
Après avoir créé le nouveau `SqsAsyncBatchManager`, utilisez-le pour envoyer plusieurs demandes à Amazon SQS (comme avec `SqsAsyncClient`), par exemple :
```
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);
```
### Configuration SqsAsyncBatchManager
`SqsAsyncBatchManager` est préconfiguré avec des paramètres qui fonctionnent dans la plupart des cas d'utilisation. Vous pouvez configurer davantage `SqsAsyncBatchManager`, par exemple :
Création d'une configuration personnalisée via `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();
```
**Paramètres dans l’`BatchOverrideConfiguration`**
| Paramètre | Valeur par défaut | Description |
| --- | --- | --- |
| maxBatchSize | 10 requêtes par lot | Nombre maximal de messages traités dans un même lot dans le cadre d'une seule requête. Plus ce paramètre est élevé, moins le nombre de lots requis pour effectuer le même nombre de requêtes est élevé. La valeur maximale autorisée pour Amazon SQS est de 10 demandes par lot. |
| sendRequestFrequency | 200 ms | Durée maximale, en millisecondes, pendant laquelle un appel sortant attend d'autres appels du même type pour le traitement par lots. Plus le paramètre est élevé, moins il faut de lots pour effectuer la même quantité de travail (toutefois, le premier appel d'un lot doit passer plus de temps à attendre). Lorsque ce paramètre est défini sur `0`, les requêtes envoyées n'attendent pas d'autres requêtes, ce qui a pour effet de désactiver le traitement par lots. |
| receiveMessageVisibilityTimeout | -1 | Lorsqu'une valeur positive autre que zéro a été définie pour ce paramètre, le délai de visibilité définit ici prévaut sur celui de la file d'attente à partir de laquelle les messages sont consommés. `1` indique que le paramètre par défaut est sélectionné pour la file d'attente. Vous ne pouvez pas définir de délai de visibilité sur `0`. |
| receiveMessageMinWaitDuration | 50 millisecondes | Durée minimale (en millisecondes) pendant laquelle un `receiveMessage` appel attend que les messages disponibles soient récupérés. Plus le paramètre est élevé, moins il faut de lots pour exécuter le même nombre de demandes. |