Trabalhando com Filas em TypeScript: Redis Bull e RabbitMQ

Neste artigo, exploraremos duas populares bibliotecas para o gerenciamento de filas em aplicações TypeScript no Node.js: Redis Bull e RabbitMQ. Filas desempenham um papel fundamental no desenvolvimento de sistemas assíncronos e escaláveis, permitindo o processamento de tarefas em segundo plano e a comunicação entre microservices.

Redis Bull

O Redis Bull é uma biblioteca que oferece uma implementação de fila baseada em Redis. Ele é amplamente utilizado para tarefas como processamento em segundo plano, envio de e-mails em fila e agendamento de trabalhos.

Principais Recursos do Redis Bull

Fácil Configuração: Configurar e iniciar uma fila é simples e direto.
Processamento Concorrente: Permite executar várias instâncias do trabalhador para processar filas em paralelo.
Recuperação de Falhas: Lida com falhas e recupera trabalhos não processados.
Agendamento de Tarefas: Agende tarefas para serem executadas em momentos específicos.
Interface Web: Oferece uma interface web para monitoramento e gerenciamento das filas.

RabbitMQ

O RabbitMQ é um sistema de mensagens de código aberto amplamente adotado para a comunicação entre microservices. Ele utiliza o protocolo AMQP (Advanced Message Queuing Protocol) para garantir a entrega confiável de mensagens entre aplicativos distribuídos.

Principais Recursos do RabbitMQ

Filas Duráveis: As filas podem ser configuradas como duráveis, garantindo que as mensagens não sejam perdidas em caso de falha.
Trocas e Roteamento: Permite a criação de regras de roteamento sofisticadas para direcionar mensagens para filas específicas.
Integração com Diversas Linguagens: Oferece suporte a várias linguagens de programação, incluindo TypeScript/Node.js.
Garantia de Entrega: Garante a entrega de mensagens, mesmo em ambientes distribuídos.

Usando Redis Bull e RabbitMQ em TypeScript

Em aplicações TypeScript, você pode aproveitar a tipagem estática para criar código mais seguro e confiável ao trabalhar com filas. Ambas as bibliotecas, Redis Bull e RabbitMQ, oferecem suporte para TypeScript, permitindo uma experiência de desenvolvimento mais produtiva.

Nas próximas seções, exploraremos exemplos práticos de como configurar e usar Redis Bull e RabbitMQ em projetos TypeScript no Node.js.

Fique atento para os próximos artigos, onde mergulharemos mais fundo no uso dessas bibliotecas e como elas podem ser aplicadas em cenários reais de desenvolvimento.

Agora que você tem uma visão geral das opções disponíveis para trabalhar com filas em TypeScript, escolher a melhor abordagem dependerá dos requisitos e da arquitetura do seu projeto. Ambas as bibliotecas oferecem soluções robustas para lidar com tarefas assíncronas e comunicação entre serviços, permitindo que você construa sistemas escaláveis e resilientes.

Neste exemplo, demonstraremos como usar o Redis Bull para criar uma fila e adicionar tarefas a ela em um projeto TypeScript no Node.js.

Instalação e Configuração

Antes de começar, você precisa ter o Redis instalado e configurado em sua máquina. Você pode seguir as instruções de instalação do site oficial do Redis.

Depois de configurar o Redis, você pode criar um projeto Node.js e instalar o pacote bull para o Redis Bull:

npm install bull

Criando fila e adicionando Tarefas

Aqui está um exemplo de como criar uma fila com Redis Bull e adicionar tarefas a ela:

import { Queue } from 'bull'

// Crie uma instância da fila
const queue = new Queue('my-queue', {
  redis: {
    host: 'localhost',
    port: 6379, // Porta padrão do Redis
  },
})

// Adicione uma tarefa à fila
queue.add('enviar-email', { destinatario: 'exemplo@email.com', mensagem: 'Olá, mundo!' })

Consumindo os dados da Fila

Exemplo de criação de um consumer, responsável por consumir a fila e notificar a mesma que a mensagem foi consumida e retirada da fila

// Crie um trabalhador para processar tarefas da fila
const worker = new Worker('my-queue', async (job) => {
  const { destinatario, mensagem } = job.data

  // Aqui, você pode implementar a lógica para processar a tarefa, por exemplo, enviar um e-mail
  console.log(`Enviando e-mail para ${destinatario}: ${mensagem}`)
})

// Inicie o trabalhador
worker.on('completed', (job) => {
  console.log(`Tarefa concluída: ${job.id}`)
})

// Lide com erros do trabalhador
worker.on('failed', (job, err) => {
  console.error(`Tarefa falhou: ${job.id}, erro: ${err}`)
})

Fila em rabbitmq

Outro exemplo do mesmo comportamento porem utilizando outra tecnologia, podemos perceber que é um pouco mais verposa mas apresenta qualidades no controle de informção que é processada e é retirada da fila com observção na código channel.ack, que retira a mensagem da fila toda ves que ela é recebida.

import * as amqp from 'amqplib'

// Configurações do RabbitMQ
const rabbitMQUrl = 'amqp://localhost'
const queueName = 'minha-fila'

async function consumeQueue() {
  try {
    // Conecte-se ao servidor RabbitMQ
    const connection = await amqp.connect(rabbitMQUrl)
    const channel = await connection.createChannel()

    // Declare a fila a ser consumida
    await channel.assertQueue(queueName)

    console.log(`Aguardando mensagens na fila: ${queueName}`)

    // Configure o consumidor
    channel.consume(queueName, (message) => {
      if (message !== null) {
        const content = message.content.toString()
        console.log(`Mensagem recebida: ${content}`)
        // Aqui, você pode implementar a lógica para processar a mensagem

        // Confirme o recebimento da mensagem
        channel.ack(message)
      }
    })
  } catch (error) {
    console.error('Erro ao consumir a fila:', error)
  }
}

consumeQueue()