rabbitmq: A JavaScript repository from brunogcp

RABBITMQ

🚀 Introdução ao RabbitMQ

RabbitMQ é um message broker avançado, ideal para sistemas que necessitam de comunicação eficiente e escalável entre componentes. Com Node.js, RabbitMQ facilita o processamento assíncrono de mensagens e tarefas, melhorando significativamente a eficiência e a escalabilidade das aplicações.

🌟 Principais Características:

⚡ Alto Desempenho e Escalabilidade: Ideal para o manejo de alto volume de mensagens.
🔄 Flexibilidade: Suporta diversos padrões de mensagens.
✔️ Confiabilidade: Garante a entrega e persistência de mensagens.
🌐 Compatibilidade Multi-Linguagem: Funciona perfeitamente com várias linguagens, incluindo Node.js.

🛠️ Instalação

Windows:

Para instalar o RabbitMQ no Windows, visite a página oficial e siga as instruções: Instalar RabbitMQ no Windows.

Linux (Ubuntu/Debian):

sudo apt-get install rabbitmq-server 📦
sudo systemctl start rabbitmq-server ▶️

macOS (Homebrew):

Instale o Homebrew, se necessário. 🍺
brew install rabbitmq 📦
brew services start rabbitmq ▶️

📊 Uso Básico

Configuração Inicial:

🔧 Primeiros passos com o RabbitMQ e Node.js:

Inicio o projeto node: npm init -y.
Instale o cliente RabbitMQ para Node.js: npm install amqplib.
Crie uma conexão básica e uma fila simples no RabbitMQ.

Exemplo Básico em Node.js:

Crio o arquivo index.js

// index.js
const amqp = require('amqplib');

async function connect() {
    const connection = await amqp.connect("amqp://localhost");
    const channel = await connection.createChannel();
    const queueName = "simple_queue";

    await channel.assertQueue(queueName, { durable: true // A fila não será perdida mesmo que o RabbitMQ reinicie 
    });
    console.log('🎉 Conectado ao RabbitMQ e fila criada.');
}

connect();

Execute o arquivo index.js: node index.js

Publicador (Publisher)

Vamos criar um arquivo chamado publisher.js:

const amqp = require('amqplib');

async function publishMessage() {
    try {
        const connection = await amqp.connect("amqp://localhost");
        const channel = await connection.createChannel();

        const exchangeName = "logs";
        const msg = "Hello World!";

        await channel.assertExchange(exchangeName, 'fanout', {
            durable: false
        });

        channel.publish(exchangeName, '', Buffer.from(msg));
        console.log("📤 Mensagem enviada:", msg);

        setTimeout(() => {
            connection.close();
            process.exit(0);
        }, 500);
    } catch (error) {
        console.error("Erro:", error);
    }
}

publishMessage();

Inscrever (Subscriber)

Vamos criar um arquivo chamado subscriber.js:

const amqp = require('amqplib');

async function startSubscriber() {
    try {
        const connection = await amqp.connect("amqp://localhost");
        const channel = await connection.createChannel();

        const exchangeName = "logs";

        await channel.assertExchange(exchangeName, 'fanout', {
            durable: false
        });

        const q = await channel.assertQueue('', {
            exclusive: true
        });

        console.log("🔍 Aguardando por mensagens em", q.queue);
        channel.bindQueue(q.queue, exchangeName, '');

        channel.consume(q.queue, message => {
            if (message.content) {
                console.log("📩 Mensagem recebida:", message.content.toString());
            }
        }, {
            noAck: true
        });
    } catch (error) {
        console.error("Erro:", error);
    }
}

startSubscriber();

Como Funciona:

Publisher:
- Conecta-se ao RabbitMQ.
- Declara uma "exchange" do tipo fanout, que transmite as mensagens para todas as filas conhecidas.
- Publica uma mensagem na "exchange".
Subscriber:
- Conecta-se ao RabbitMQ.
- Declara a mesma "exchange".
- Cria uma fila temporária exclusiva para esse subscriber.
- Liga a fila à "exchange".
- Consome mensagens da fila.

Testando o Exemplo:

Execute subscriber.js em um terminal para começar a escutar as mensagens.
Execute publisher.js em outro terminal para enviar uma mensagem.
Você verá que a mensagem enviada pelo publicador é recebida pelo inscrito.

📈 RabbitMQ para Envio de Emails

Teoria do Envio de Emails com RabbitMQ:

💡 O RabbitMQ permite que tarefas como o envio de e-mails sejam enfileiradas e processadas de forma assíncrona, evitando sobrecarga no servidor principal e melhorando a eficiência geral da aplicação.

Motivo para Utilizar o RabbitMQ para Emails:

🚀 Utilizar o RabbitMQ para envio de e-mails permite gerenciar grandes volumes de e-mails de forma eficiente, sem afetar o desempenho da aplicação principal.

Criação do Sistema de Envio de Emails:

👨‍💻 Implementação de um sistema de envio de e-mails usando RabbitMQ e Node.js.

Configuração:
- Instale RabbitMQ e Node.js.
- Instale os pacotes amqplib e nodemailer: npm install amqplib nodemailer
Publicador (Publisher):

// email-publisher.js
const amqp = require('amqplib');

const emailQueue = "email_queue";

async function sendEmailRequest(emailDetails) {
    const connection = await amqp.connect("amqp://localhost");
    const channel = await connection.createChannel();

    await channel.assertQueue(emailQueue, { durable: true });
    channel.sendToQueue(emailQueue, Buffer.from(JSON.stringify(emailDetails)), { persistent: true });

    console.log("📧 Pedido de email enviado:", emailDetails);
    setTimeout(() => {
        connection.close();
    }, 500);
}

// Exemplo de detalhes do email
const emailDetails = {
    to: "destinatario@example.com",
    subject: "Assunto do Email",
    body: "Corpo do Email"
};

sendEmailRequest(emailDetails);

Consumidor (Consumer):

// email-consumer.js
const amqp = require('amqplib');
const nodemailer = require('nodemailer');

const emailQueue = "email_queue";

async function startConsumer() {
    const connection = await amqp.connect("amqp://localhost");
    const channel = await connection.createChannel();

    await channel.assertQueue(emailQueue, { durable: true });
    console.log("🔍 Aguardando pedidos de email...");

    channel.consume(emailQueue, async message => {
        const emailDetails = JSON.parse(message.content.toString());
        console.log("📩 Enviando email:", emailDetails);

        // Configuração do Nodemailer para enviar o email
        let transporter = nodemailer.createTransport({
		    host: "smtp.example.com",   // Substitua pelo host do seu provedor SMTP
		    port: 587,                  // Porta para SMTP seguro, use 465 para SSL
		    secure: false,              // true para 465, false para outras portas
		    auth: {
		        user: "seuemail@example.com",  // Seu endereço de e-mail
		        pass: "suasenha"              // Sua senha de e-mail
		    },
		    tls: {
		        rejectUnauthorized: false  // Necessário para alguns servidores que usam certificados autoassinados
		    }
		});

        let info = await transporter.sendMail({
            from: '"Nome do Remetente" <seuemail@example.com>',
            to: emailDetails.to,
            subject: emailDetails.subject,
            text: emailDetails.body
        });

        console.log("Email enviado:", info.messageId);
        channel.ack(message);
    });
}

startConsumer();

🔍 Testes:

Verificação do Envio de Emails:
- Execute publisher.js para enviar um pedido de email.
- Execute consumer.js para processar o pedido e enviar o email.
- Verifique a saída do console no consumer.js para confirmar o envio.

🏆 Conclusão

Neste tutorial, exploramos o RabbitMQ em combinação com Node.js, uma dupla poderosa para gerenciar mensagens e tarefas de maneira eficiente e escalável. A utilização do RabbitMQ para processar tarefas demoradas ilustra perfeitamente como ele pode melhorar significativamente a performance de aplicações web.

Espero que este guia tenha sido útil e inspirador, e que você se sinta preparado para incorporar o RabbitMQ em seus próprios projetos. Continue explorando, experimentando e, acima de tudo, se divertindo com a programação! 🐇💻

brunogcp/rabbitmq