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.

Por que usar o AWS SQS?

Separei 6 pontos bem legais e compreensíveis:

Desacoplamento de sistemas: O SQS permite que diferentes partes de um sistema distribuído se comuniquem sem precisar conhecer detalhes uns dos outros. Isso promove um forte desacoplamento, permitindo a evolução independente de cada componente.
Escalabilidade e Confiabilidade: É altamente escalável e confiável, com capacidade para lidar com grandes volumes de mensagens sem perder a entrega. Ele gerencia automaticamente a escalabilidade e a replicação, garantindo a entrega confiável das mensagens.
Garantia de entrega de mensagens: O SQS oferece uma garantia de entrega pelo menos uma vez, o que significa que as mensagens serão entregues ao menos uma vez ao consumidor, evitando a perda de informações importantes.
Tempo de processamento flexível: Ele permite que diferentes partes do sistema processem mensagens em seu próprio tempo, sendo útil para lidar com picos de tráfego, balanceando a carga e evitando sobrecarga em determinados serviços.
Integração com outros serviços AWS: O SQS pode ser facilmente integrado com outros serviços da AWS, como Lambda, EC2, S3, entre outros, permitindo a construção de arquiteturas mais complexas e poderosas.
Custo-efetividade: Oferece um modelo de pagamento conforme o uso, o que significa que você paga apenas pelo número de requisições e pela quantidade de dados transferidos, tornando-o uma opção custo-efetiva para sistemas distribuídos.

Quando usar Kafka ou SQS?

Kafka: Para casos de uso que exigem alto desempenho, processamento de streams, capacidade de retenção e processamento de eventos em tempo real.
SQS: Para sistemas que priorizam a facilidade de uso, escalabilidade automática e integração com o ecossistema da AWS, especialmente para comunicação assíncrona entre componentes distribuídos.

Para poder responder, a escolha entre Kafka e SQS depende das necessidades específicas do seu sistema, do tipo de processamento de mensagens necessário, dos requisitos de desempenho e das preferências em relação à infraestrutura gerenciada.

Conclusão sobre AWS SQS com Spring Boot

Ao escolher o SQS, as equipes de desenvolvimento podem contar com um serviço robusto que permite desacoplamento, facilita a escalabilidade sem preocupações com infraestrutura, oferece garantias de entrega e se integra de maneira eficaz a outros serviços da AWS.

Isso proporciona flexibilidade e confiabilidade para a construção de sistemas distribuídos complexos, ao mesmo tempo em que ajuda a reduzir a sobrecarga operacional, permitindo que as equipes se concentrem mais na lógica de negócios e menos na administração da infraestrutura de mensageria.

Em resumo, o SQS se destaca como uma solução valiosa para a troca de mensagens assíncronas em arquiteturas distribuídas na nuvem, Saiba mais sobre o SQS.

4/5 - (1 vote)