Gestion des files d'attente Amazon SQS en Java
1. Vue d'ensemble
Dans ce didacticiel, nous allons découvrir commentuse Amazon’s SQS (Simple Queue Service) using the Java SDK.
2. Conditions préalables
Les dépendances Maven, les paramètres de compte AWS et la connexion client nécessaires pour utiliser le kit SDK Amazon AWS pour SQS sont les mêmes que dansthis article here.
En supposant que nous ayons créé une instance deAWSCredentials, comme décrit dans l'article précédent, nous pouvons continuer et créer notre client SQS:
AmazonSQS sqs = AmazonSQSClientBuilder.standard()
.withCredentials(new AWSStaticCredentialsProvider(credentials))
.withRegion(Regions.US_EAST_1)
.build();3. Créer des files d'attente
Une fois que nous avons configuré notre client SQS,creating queues is fairly straightforward.
3.1. Création d'une file d'attente standard
Voyons comment nous pouvons créer une file d'attente standard. Pour ce faire,we’ll need to create an instance of CreateQueueRequest:
CreateQueueRequest createStandardQueueRequest = new CreateQueueRequest("example-queue");
String standardQueueUrl = sqs.createQueue(createStandardQueueRequest).getQueueUrl();3.2. Création d'une file d'attente FIFO
La création d'une FIFO est similaire à la création d'une file d'attente standard. Nous utiliserons toujours une instance deCreateQueueRequest, comme nous l'avons fait précédemment. Seulement cette fois,we’ll have to pass in queue attributes, and set the FifoQueue attribute to true:
Map queueAttributes = new HashMap<>();
queueAttributes.put("FifoQueue", "true");
queueAttributes.put("ContentBasedDeduplication", "true");
CreateQueueRequest createFifoQueueRequest = new CreateQueueRequest(
"example-queue.fifo").withAttributes(queueAttributes);
String fifoQueueUrl = sqs.createQueue(createFifoQueueRequest)
.getQueueUrl(); 4. Publication de messages dans les files d'attente
Une fois nos files d'attente configurées, nous pouvons commencer à envoyer des messages.
4.1. Publication d'un message dans une file d'attente standard
Pour envoyer des messages à une file d'attente standard, nous allonshave to create an instance of SendMessageRequest.
Ensuite, nous attachons une carte d'attributs de message à cette demande:
Map messageAttributes = new HashMap<>();
messageAttributes.put("AttributeOne", new MessageAttributeValue()
.withStringValue("This is an attribute")
.withDataType("String"));
SendMessageRequest sendMessageStandardQueue = new SendMessageRequest()
.withQueueUrl(standardQueueUrl)
.withMessageBody("A simple message.")
.withDelaySeconds(30)
.withMessageAttributes(messageAttributes);
sqs.sendMessage(sendMessageStandardQueue); LewithDelaySeconds() indique après combien de temps le message doit arriver dans la file d'attente.
4.2. Publication d'un message dans une file d'attente FIFO
La seule différence, dans ce cas, est quewe’ll have to specify the group to which the message belongs:
SendMessageRequest sendMessageFifoQueue = new SendMessageRequest()
.withQueueUrl(fifoQueueUrl)
.withMessageBody("Another simple message.")
.withMessageGroupId("example-group-1")
.withMessageAttributes(messageAttributes);Comme vous pouvez le voir dans l'exemple de code ci-dessus, nous spécifions le groupe en utilisantwithMessageGroupId().
4.3. Publication de plusieurs messages dans une file d'attente
Nous pouvons aussipost multiple messages to a queue, using a single request. Nous allons créer une liste deSendMessageBatchRequestEntry que nous enverrons en utilisant une instance deSendMessageBatchRequest:
List messageEntries = new ArrayList<>();
messageEntries.add(new SendMessageBatchRequestEntry()
.withId("id-1")
.withMessageBody("batch-1")
.withMessageGroupId("example-group-1"));
messageEntries.add(new SendMessageBatchRequestEntry()
.withId("id-2")
.withMessageBody("batch-2")
.withMessageGroupId("example-group-1"));
SendMessageBatchRequest sendMessageBatchRequest
= new SendMessageBatchRequest(fifoQueueUrl, messageEntries);
sqs.sendMessageBatch(sendMessageBatchRequest); 5. Lire des messages à partir de files d'attente
Nous pouvons recevoir des messages de nos files d'attente parinvoking the receiveMessage() method on an instance of ReceiveMessageRequest:
ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(fifoQueueUrl)
.withWaitTimeSeconds(10)
.withMaxNumberOfMessages(10);
List sqsMessages = sqs.receiveMessage(receiveMessageRequest).getMessages(); En utilisantwithMaxNumberOfMessages(),, nous spécifions le nombre de messages à obtenir de la file d'attente - bien qu'il convient de noter que le maximum est10.
La méthodewithWaitTimeSeconds() activelong-polling. L'interrogation longue est un moyen de limiter le nombre de demandes de réception de messages que nous envoyons à SQS.
En termes simples, cela signifie que nous allons attendre le nombre de secondes spécifié pour récupérer un message. S'il n'y a aucun message dans la file d'attente pendant cette durée, la demande retournera vide. Si un message arrive dans la file d'attente pendant ce temps, il sera renvoyé.
On peutget the attributes and body of a given message:
sqsMessages.get(0).getAttributes();
sqsMessages.get(0).getBody();6. Suppression d'un message d'une file d'attente
Pour supprimer un message, nous utiliserons unDeleteMessageRequest:
sqs.deleteMessage(new DeleteMessageRequest()
.withQueueUrl(fifoQueueUrl)
.withReceiptHandle(sqsMessages.get(0).getReceiptHandle()));7. Files d'attente de lettres mortes
A dead letter queue must be of the same type as its base queue — it doit être FIFO si la file d'attente de base est FIFO, et standard si la file d'attente de base est standard. Pour cet exemple, nous utiliserons une file d'attente standard.
La première chose à faire est decreate what will become our dead letter queue:
String deadLetterQueueUrl = sqs.createQueue("example-dead-letter-queue").getQueueUrl();Ensuite, nous allonsget our newly created queue’s ARN (Amazon Resource Name):
GetQueueAttributesResult deadLetterQueueAttributes = sqs.getQueueAttributes(
new GetQueueAttributesRequest(deadLetterQueueUrl)
.withAttributeNames("QueueArn"));
String deadLetterQueueARN = deadLetterQueueAttributes.getAttributes()
.get("QueueArn");Enfin, nousset this newly created queue to be our original standard queue’s dead letter queue:
SetQueueAttributesRequest queueAttributesRequest = new SetQueueAttributesRequest()
.withQueueUrl(standardQueueUrl)
.addAttributesEntry("RedrivePolicy",
"{\"maxReceiveCount\":\"2\", "
+ "\"deadLetterTargetArn\":\"" + deadLetterQueueARN + "\"}");
sqs.setQueueAttributes(queueAttributesRequest);The JSON packet we set in the addAttributesEntry() method when building our SetQueueAttributesRequest instance contains the information we need: lemaxReceiveCount est2, ce qui signifie que si un message est reçu autant de fois, il est supposé ne pas avoir été traité correctement et est envoyé à notre file d'attente de lettres mortes.
L'attributdeadLetterTargetArn pointe notre file d'attente standard vers notre file d'attente de lettres mortes nouvellement créée.
8. surveillance
Nous pouvonscheck how many messages are currently in a given queue, and how many are in flight with the SDK. Premièrement, nous devons créer unGetQueueAttributesRequest.
À partir de là, nous vérifierons l'état de la file d'attente:
GetQueueAttributesRequest getQueueAttributesRequest
= new GetQueueAttributesRequest(standardQueueUrl)
.withAttributeNames("All");
GetQueueAttributesResult getQueueAttributesResult
= sqs.getQueueAttributes(getQueueAttributesRequest);
System.out.println(String.format("The number of messages on the queue: %s",
getQueueAttributesResult.getAttributes()
.get("ApproximateNumberOfMessages")));
System.out.println(String.format("The number of messages in flight: %s",
getQueueAttributesResult.getAttributes()
.get("ApproximateNumberOfMessagesNotVisible")));Une surveillance plus approfondie peut être obtenue en utilisantAmazon Cloud Watch.
9. Conclusion
Dans cet article, nous avons vu commentmanage SQS queues using the AWS Java SDK.
Comme d'habitude, tous les exemples de code utilisés dans l'article peuvent être trouvésover on GitHub.