Amazon Simple Queue Service (SQS) is a fully managed message queuing service. AWS provides two types of SQS queues: Standard and FIFO (First-In-First-Out). Let us delve into understanding Spring Cloud AWS FIFO queue support.<\/p>\n
FIFO (First-In-First-Out) is a queue processing mechanism where messages are processed in the exact order in which they arrive. This ensures that no message overtakes another, maintaining strict order. Additionally, FIFO prevents duplicates, guaranteeing that each message is delivered and processed exactly once. This is particularly useful in scenarios where order consistency is critical, such as financial transactions<\/a>, inventory management, and task scheduling.<\/p>\n Amazon Simple Queue Service (SQS)<\/a> is a fully managed message queuing service that enables applications to communicate asynchronously by sending, storing, and receiving messages at scale. It helps decouple the components of distributed applications, improving their resilience and scalability.<\/p>\n AWS SQS provides two types of queues:<\/p>\n With AWS SQS, developers can:<\/p>\n Testcontainers<\/a> is an open-source library that enables developers to create lightweight, throwaway instances of databases, message brokers, and other services in Docker containers for integration testing. It simplifies the process of setting up and managing dependencies, ensuring consistent test environments. The key benefits of Testcontainers include improved test reliability, faster feedback loops, and easier setup of complex dependencies. It is widely used for testing microservices, database interactions, and cloud-native applications without requiring dedicated infrastructure. By leveraging Docker<\/a>, Testcontainers provides a clean, isolated environment, reducing flakiness in tests and making continuous integration pipelines more robust.<\/p>\n LocalStack<\/a><\/strong> is an open-source tool that provides a fully functional local AWS cloud environment, enabling developers to test and develop cloud applications without needing access to an actual AWS account. It simulates core AWS services such as S3, DynamoDB, Lambda, API Gateway, and more, allowing users to run their cloud applications entirely on their local machines. By leveraging LocalStack, developers can accelerate their development cycles, reduce costs associated with AWS usage, and ensure their applications work correctly before deploying them to a real AWS environment. It integrates seamlessly with CI\/CD pipelines and supports both Docker-based and native installations, making it a versatile tool for cloud-native application development. <\/p>\n We use TestContainers to run LocalStack in an isolated environment. Ensure that Docker<\/a> is installed on your machine before proceeding.<\/p>\n The Create a Spring Boot application using Spring Initializr<\/a>. <\/p>\n Add the following dependencies in LocalStack works well with the AWS Command Line Interface (CLI)<\/a>, allowing developers to interact with AWS services using familiar commands. If you haven’t installed the AWS CLI yet, follow the official installation guide<\/a> to set it up. Use the following AWS CLI command to create a FIFO queue in LocalStack:<\/p>\n When this command runs successfully, AWS SQS (emulated by LocalStack) will return a JSON response containing the queue URL. To verify that the queue was created, use the following command:<\/p>\n This will return a list of all available queues, including the newly created FIFO queue. You can then send and receive messages from this queue using AWS SDKs, CLI commands, or LocalStack-based integrations.<\/p>\n This configuration sets up AWS SQS using LocalStack.<\/p>\n The This service handles sending messages to the FIFO queue.<\/p>\n The This listener will process messages as they arrive.<\/p>\n The This REST controller provides an endpoint to send messages.<\/p>\n The Include the following properties in the To start the application, run the main class from your IDE or use the following command:<\/p>\n You can test the API using cURL<\/a> or Postman<\/a>. Execute the following cURL command:<\/p>\n If everything goes well, the following response will be logged on the IDE console:<\/p>\n If you want to send messages to different group IDs, feel free to explore the app.<\/p>\n In this article, we explored FIFO queue support in Spring Cloud AWS using LocalStack and Testcontainers for local testing. We configured a Spring Boot application to send and receive messages while ensuring ordered processing with Amazon Simple Queue Service (SQS) is a fully managed message queuing service. AWS provides two types of SQS queues: Standard and FIFO (First-In-First-Out). Let us delve into understanding Spring Cloud AWS FIFO queue support. 1. Understanding FIFO and AWS SQS 1.1 What is FIFO (First-In-First-Out)? FIFO (First-In-First-Out) is a queue processing mechanism where messages are …<\/p>\n","protected":false},"author":26931,"featured_media":130513,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8],"tags":[758,992,3300],"class_list":["post-132625","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-enterprise-java","tag-aws","tag-spring-cloud","tag-spring-cloud-aws"],"yoast_head":"\n1.2 What is AWS SQS?<\/h3>\n
\n
\n
1.3 What are TestContainers?<\/h3>\n
<\/a>2. Running LocalStack in a TestContainer<\/h2>\n
\nimport org.testcontainers.containers.GenericContainer;\nimport org.testcontainers.utility.DockerImageName;\n\npublic class LocalStackContainer {\n public static void main(String[] args) {\n \/\/ Create a GenericContainer instance for LocalStack\n GenericContainer<?> localStack = new GenericContainer<>(DockerImageName.parse(\"localstack\/localstack\"))\n \/\/ Expose port 4566, which is used for AWS service emulation in LocalStack\n .withExposedPorts(4566)\n \/\/ Set environment variable to enable the SQS (Simple Queue Service) in LocalStack\n .withEnv(\"SERVICES\", \"sqs\");\n \n \/\/ Start the LocalStack container\n localStack.start();\n \n \/\/ Print the LocalStack host address to verify it's running\n System.out.println(\"LocalStack running at: \" + localStack.getHost());\n }\n}\n<\/pre>\n2.1 Code Explanation<\/h3>\n
LocalStackContainer<\/code> class initializes and starts a LocalStack container using the Testcontainers library. It defines a GenericContainer<\/code> instance, specifying the LocalStack Docker image (localstack\/localstack<\/code>) using DockerImageName.parse<\/code>. The container is configured to expose port 4566<\/code>, which is the default entry point for AWS services in LocalStack. Additionally, the environment variable SERVICES<\/code> is set to sqs<\/code>, ensuring that only the Amazon Simple Queue Service (SQS) is enabled. The localStack.start()<\/code> method launches the container, making LocalStack available for local AWS service testing. Finally, the program prints the hostname of the running container using System.out.println(\"LocalStack running at: \" + localStack.getHost())<\/code>, which helps verify that LocalStack is successfully started and accessible.<\/a>3. Code Example<\/h2>\n
3.1 Adding Dependencies<\/h3>\n
pom.xml<\/code> file:<\/p>\n\n<dependencies>\n <!-- Spring Boot Web -->\n <dependency>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-web<\/artifactId>\n <\/dependency>\n\n <!-- Spring Boot Messaging for AWS SQS -->\n <dependency>\n <groupId>org.springframework.cloud<\/groupId>\n <artifactId>spring-cloud-aws-messaging<\/artifactId>\n <version>2.2.6.RELEASE<\/version>\n <\/dependency>\n\n <!-- AWS SDK for Java -->\n <dependency>\n <groupId>com.amazonaws<\/groupId>\n <artifactId>aws-java-sdk-sqs<\/artifactId>\n <version>1.12.297<\/version>\n <\/dependency>\n\n <!-- Lombok for reducing boilerplate code -->\n <dependency>\n <groupId>org.projectlombok<\/groupId>\n <artifactId>lombok<\/artifactId>\n <scope>provided<\/scope>\n <\/dependency>\n\n <!-- Testcontainers for local AWS SQS testing -->\n <dependency>\n <groupId>org.testcontainers<\/groupId>\n <artifactId>localstack<\/artifactId>\n <version>1.17.6<\/version>\n <scope>test<\/scope>\n <\/dependency>\n\n <dependency>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-test<\/artifactId>\n <scope>test<\/scope>\n <\/dependency>\n<\/dependencies>\n<\/pre>\n
3.2 Creating FIFO Queue<\/h3>\n
\naws --endpoint-url=http:\/\/localhost:4566 sqs create-queue --queue-name myqueue.fifo --attributes FifoQueue=true\n<\/pre>\n
\naws --endpoint-url=http:\/\/localhost:4566 sqs list-queues\n<\/pre>\n
3.3 AWS SQS Setup Configuration<\/h3>\n
\npackage com.example.sqs.config;\n\nimport com.amazonaws.auth.AWSStaticCredentialsProvider;\nimport com.amazonaws.auth.BasicAWSCredentials;\nimport com.amazonaws.client.builder.AwsClientBuilder;\nimport com.amazonaws.services.sqs.AmazonSQSAsync;\nimport com.amazonaws.services.sqs.AmazonSQSAsyncClientBuilder;\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.context.annotation.Configuration;\n\n@Configuration\npublic class SqsConfig {\n\n @Bean\n public AmazonSQSAsync amazonSQSAsync() {\n return AmazonSQSAsyncClientBuilder.standard()\n .withEndpointConfiguration(new AwsClientBuilder.EndpointConfiguration(\n \"http:\/\/localhost:4566\", \"us-east-1\"))\n .withCredentials(new AWSStaticCredentialsProvider(\n new BasicAWSCredentials(\"access\", \"secret\")))\n .build();\n }\n}\n<\/pre>\n3.3.1 Code Explanation<\/h4>\n
SqsConfig<\/code> class is a Spring configuration class, annotated with @Configuration<\/code>, that defines a bean for integrating with AWS Simple Queue Service (SQS). The amazonSQSAsync<\/code> method, annotated with @Bean<\/code>, creates and returns an instance of AmazonSQSAsync<\/code> using the AmazonSQSAsyncClientBuilder<\/code>. It sets the endpoint configuration to http:\/\/localhost:4566<\/code>, which is the default LocalStack URL for AWS service emulation, and specifies the AWS region as us-east-1<\/code>. The method also provides static AWS credentials using AWSStaticCredentialsProvider<\/code> and BasicAWSCredentials<\/code>, where placeholder values (“access” and “secret”) are used since LocalStack does not require real AWS credentials. This configuration allows Spring applications to interact with a locally hosted SQS instance for testing and development purposes.<\/p>\n3.4 SQS Service (Message Sender & Listener)<\/h3>\n
\npackage com.example.sqs.service;\n\nimport com.amazonaws.services.sqs.AmazonSQSAsync;\nimport com.amazonaws.services.sqs.model.SendMessageRequest;\nimport lombok.RequiredArgsConstructor;\nimport org.springframework.stereotype.Service;\n\nimport java.util.UUID;\n\n@Service\n@RequiredArgsConstructor\npublic class SqsMessageService {\n\n private final AmazonSQSAsync amazonSQSAsync;\n private final String queueUrl = \"http:\/\/localhost:4566\/000000000000\/myqueue.fifo\";\n\n public void sendMessage(String message, String messageGroupId) {\n SendMessageRequest sendMessageRequest = new SendMessageRequest()\n .withQueueUrl(queueUrl)\n .withMessageBody(message)\n .withMessageGroupId(messageGroupId)\n .withMessageDeduplicationId(UUID.randomUUID().toString());\n\n amazonSQSAsync.sendMessage(sendMessageRequest);\n }\n}\n<\/pre>\n3.4.1 Code Explanation<\/h4>\n
SqsMessageService<\/code> class is a Spring service, annotated with @Service<\/code>, responsible for sending messages to an Amazon SQS FIFO queue. It uses the @RequiredArgsConstructor<\/code> annotation from Lombok to automatically inject dependencies, specifically an instance of AmazonSQSAsync<\/code> for asynchronous communication with SQS. The queue URL is defined as a constant, pointing to a LocalStack-hosted FIFO queue. The sendMessage<\/code> method constructs a SendMessageRequest<\/code>, setting the queue URL, message body, and messageGroupId<\/code>, which is required for FIFO queues to ensure ordered processing. Additionally, it includes a unique messageDeduplicationId<\/code> generated using UUID.randomUUID().toString()<\/code> to prevent duplicate message delivery. Finally, the message is sent asynchronously using amazonSQSAsync.sendMessage(sendMessageRequest)<\/code>, enabling reliable, ordered, and deduplicated message processing in the FIFO queue.<\/p>\n3.5 Message Listener (Processing Messages)<\/h3>\n
\npackage com.example.sqs.listener;\n\nimport org.springframework.cloud.aws.messaging.listener.annotation.SqsListener;\nimport org.springframework.messaging.handler.annotation.Header;\nimport org.springframework.stereotype.Component;\n\n@Component\npublic class SqsMessageListener {\n\n @SqsListener(\"myqueue.fifo\")\n public void receiveMessage(String message, @Header(\"MessageGroupId\") String groupId) {\n System.out.println(\"Processing message from group \" + groupId + \": \" + message);\n }\n}\n<\/pre>\n3.5.1 Code Explanation<\/h4>\n
SqsMessageListener<\/code> class is a Spring component, annotated with @Component<\/code>, that listens for incoming messages from an Amazon SQS FIFO queue. It uses the @SqsListener(\"myqueue.fifo\")<\/code> annotation to automatically subscribe to the myqueue.fifo<\/code> queue and process messages as they arrive. The receiveMessage<\/code> method takes two parameters: the message body as a String<\/code> and the MessageGroupId<\/code>, which is extracted from the message headers using the @Header(\"MessageGroupId\")<\/code> annotation. This ensures that messages belonging to the same group are processed in order. When a message is received, the method logs its content along with the group ID using System.out.println<\/code>, demonstrating how messages are consumed from the FIFO queue while maintaining their ordering guarantees.<\/p>\n3.6 Controller (Exposing API for Sending Messages)<\/h3>\n
\npackage com.example.sqs.controller;\n\nimport com.example.sqs.service.SqsMessageService;\nimport lombok.RequiredArgsConstructor;\nimport org.springframework.web.bind.annotation.*;\n\n@RestController\n@RequestMapping(\"\/sqs\")\n@RequiredArgsConstructor\npublic class SqsController {\n\n private final SqsMessageService sqsMessageService;\n\n @PostMapping(\"\/send\")\n public String sendMessage(@RequestParam String message, @RequestParam String groupId) {\n sqsMessageService.sendMessage(message, groupId);\n return \"Message sent successfully!\";\n }\n}\n<\/pre>\n3.6.1 Code Explanation<\/h4>\n
SqsController<\/code> class is a Spring REST controller, annotated with @RestController<\/code> and @RequestMapping(\"\/sqs\")<\/code>, which exposes an HTTP endpoint for sending messages to an Amazon SQS FIFO queue. It uses the @RequiredArgsConstructor<\/code> annotation from Lombok to automatically inject the SqsMessageService<\/code> dependency. The sendMessage<\/code> method, mapped to POST \/sqs\/send<\/code> using @PostMapping(\"\/send\")<\/code>, accepts two request parameters: message<\/code> (the message body) and groupId<\/code> (the message group ID for FIFO ordering). It then calls sqsMessageService.sendMessage(message, groupId)<\/code> to send the message to the queue. Upon successful execution, the method returns a simple confirmation message, \"Message sent successfully!\"<\/code>, indicating that the message has been dispatched to SQS.<\/p>\n3.7 Setting up the properties<\/h3>\n
application.properties<\/code> file located at src\/main\/resources\/application.properties<\/code>.<\/p>\n\n# Server Configuration\nserver.port=8080\n<\/pre>\n
<\/a>4. Testing the Application<\/h2>\n
\nmvn spring-boot:run\n<\/pre>\n
\ncurl -X POST \"http:\/\/localhost:8080\/sqs\/send?message=HelloWorld&groupId=Group1\"\n<\/pre>\n
\nProcessing message from group Group1: HelloWorld\n<\/pre>\n
<\/a>5. Conclusion<\/h2>\n
messageGroupId<\/code>.<\/p>\n","protected":false},"excerpt":{"rendered":"