AWS SQS com Spring Boot - Iniciando com Filas na Amazon

O Amazon Simple Queue Service (SQS) é um serviço de filas de mensagens totalmente gerenciado oferecido pela Amazon Web Services (AWS). Ele permite que os aplicativos se comuniquem e transmitam mensagens entre componentes de software de forma assíncrona, o que ajuda na desacoplagem de sistemas distribuídos, hoje vamos criar um projeto AWS SQS com Spring Boot

Integrar a Amazon SQS com aplicativos Spring Boot oferece uma maneira eficiente de criar sistemas altamente escaláveis e confiáveis.

Visão Geral do Amazon SQS

O SQS é um serviço de mensagens distribuído que funciona com o conceito de filas. Ele opera com produtores, que enviam mensagens para as filas, e consumidores, que recebem e processam essas mensagens.

As filas armazenam as mensagens temporariamente até que sejam processadas com sucesso por um consumidor. Isso permite a comunicação assíncrona entre diferentes partes de um sistema, permitindo que os componentes operem de forma independente e tolerante a falhas.

Integração da AWS SQS com Spring Boot

Para começar a utilizar este modelo de comunicação assíncrona da AWS, precisamos inicialmente criar uma queue, vá no Console da AWS e pesquise por SQS, em seguida precisamos definir um nome para nossa queue:

Antes deste processo, você precisa ter configurado o seu usuário IAM Identity and Access Management, por que vamos precisar das credenciais para poder acessar nossa queue diretamente de uma aplicação externa, como no caso nosso projeto Spring Boot.

Definimos o nome da nossa queue para: virandoprogramador-queue, ela será a fila onde vamos realizar os testes.

Agora precisamos adicionar as dependências no arquivo pom.xml para ter acesso as classes de configurações da Amazon e SQS:

<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>Hoxton.SR6</spring-cloud.version>
</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
      		// dependências da AWS e SQS
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-aws</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-aws-messaging</artifactId>
		</dependency>

Adiciona as configurações em seu arquivo application.yml:

cloud:
  aws:
    region:
      static: us-east-1
      auto: false
    credentials:
      access-key: suas_credenciais
      secret-key: suas_credenciais
    end-point:
      uri: https://sqs.us-east-1.amazonaws.com/00000000/virandoprogramador-queue

Adicione suas credencias nos campos acces-key e secret-key, que são as credenciais que você criou pelo serviço IAM da Aws, após isso adicione a URI da sua queue que você criou.

Por motivos de segurança adicionei vários “0”, porém a AWS vai disponibilizar uma URI exata para a sua queue, é muito importante seguir estes procedimentos antes de iniciar com nossas classes Java.

Após este procedimento, precisamos iniciar nossas configurações em nosso projeto Spring Boot, vamos criar a classe AwsSqsConfiguration para começar as definições de usuários, antes mesmo de criarmos os métodos:

package br.com.virandoprogramador.sqs.config

import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.sqs.AmazonSQSAsync;
import com.amazonaws.services.sqs.AmazonSQSAsyncClientBuilder;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.aws.messaging.core.QueueMessagingTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

@Configuration
public class AwsSqsConfiguration {

    @Value("${cloud.aws.region.static}")
    private String region;

    @Value("${cloud.aws.credentials.access-key}")
    private String awsAccessKey;

    @Value("${cloud.aws.credentials.secret-key}")
    private String awsSecretKey;

    @Bean
    public QueueMessagingTemplate queueMessagingTemplate() {
        return new QueueMessagingTemplate(amazonSQSAsync());
    }

    @Primary
    @Bean
    public AmazonSQSAsync amazonSQSAsync() {
        return AmazonSQSAsyncClientBuilder.standard().withRegion(Regions.AP_SOUTH_1)
                .withCredentials(new AWSStaticCredentialsProvider(new BasicAWSCredentials(awsAccessKey, awsSecretKey)))
                .build();
    }
}

Essa classe de configuração é essencial para estabelecer a conexão e configurar o cliente do SQS na aplicação Spring Boot. Ela usa as informações de região e credenciais para criar um cliente SQS assíncrono que pode ser injetado em outras partes do aplicativo para enviar e receber mensagens das filas SQS da AWS.

Agora precisamos criar uma classe AmazonSqsController para utilizar um endpoint sendMessageToQueue que recebe uma mensagem através da uri: localhost:8080/send/A MENSAGEM

package br.com.virandoprogramador.sqs.controller

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.aws.autoconfigure.context.ContextStackAutoConfiguration;
import org.springframework.cloud.aws.messaging.core.QueueMessagingTemplate;
import org.springframework.cloud.aws.messaging.listener.annotation.SqsListener;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AmazonSqsController {

    Logger logger= LoggerFactory.getLogger(AmazonSqsController.class);

    @Autowired
    private QueueMessagingTemplate queueMessagingTemplate;

    @Value("${cloud.aws.end-point.uri}")
    private String endpoint;

    @GetMapping("/send/{message}")
    public void sendMessageToQueue(@PathVariable String message) {
        queueMessagingTemplate.send(endpoint, MessageBuilder.withPayload(message).build());
    }

    @SqsListener("virandoprogramador-queue")
    public void loadMessageFromSQS(String message)  {
        logger.info("mensagem da fila SQS {}",message);
    }
}

Nesta classe se baseia da seguinte forma: @SqsListener(“virandoprogramador-queue”) Utiliza a anotação @SqsListener do Spring Cloud AWS para escutar mensagens da fila SQS chamada virandoprogramador-queue.

Quando uma mensagem é recebida nessa fila, o método loadMessageFromSQS() é acionado para processar a mensagem, registrando-a no log utilizando o Logger

Mensagem enviada para a queue

Depois de enviar uma mensagem diretamente para a nossa fila, o Spring apresenta o Logger que configuramos na classe anterior na linha 33, indicando que a nossa mensagem foi enviada para a queue virandoprogramador-queue diretamente na AWS SQS:

2023-012-05 15:19.21 INFO 1870 c.j.a.s.SpringBootAwsSqsExempleApplication  :  mensagem da fila SQS  SUA MENSAGEM

E assim chegamos ao fim de mais um tutorial passo a passo sobre a AWS SQS com Spring Boot, utilizamos um exemplo muito simples, mais que da para ter um bom entendimento sobre este modelo de mensageria com Java.

4/5 - (1 voto)