Ao projetar arquitetura de microsserviços para aplicativos orientados a eventos, a integração do Apache Kafka e Node.js pode melhorar significativamente os recursos de processamento de dados em tempo real . Neste artigo, exploraremos como aproveitar a integração Kafka Node.js para construir microsserviços robustos e escaláveis ​​que lidam com dados de streaming de forma eficiente.

Por que usar o Apache Kafka em uma arquitetura de microsserviços?

Em uma arquitetura de microsserviços, os serviços precisam se comunicar uns com os outros de forma eficiente. Apache Kafka serve como uma plataforma distribuída de streaming de eventos que permite a troca de dados em tempo real entre microsserviços. Ele desacopla os serviços, permitindo que operem de forma independente enquanto processam grandes volumes de dados.

Benefícios do Kafka em aplicativos orientados a eventos

• Escalabilidade: a arquitetura distribuída do Kafka suporta escalonamento horizontal, tornando-o ideal para processamento de dados em tempo real em aplicativos orientados a eventos.
• Tolerância a falhas: Kafka garante que os dados sejam entregues de forma confiável, mesmo em caso de falhas.
• Alto rendimento: Kafka pode lidar com milhões de eventos por segundo, fornecendo alto rendimento para aplicativos de microsserviços exigentes.

Configurando a integração Kafka Node.js

Para integrar Apache Kafka e Node.js em um ambiente de microsserviços, você precisará configurar o Kafka como um agente de mensagens e conectá-lo aos seus serviços Node.js. Aqui está um guia passo a passo:

Instale Kafka e Node.js

Primeiro, certifique-se de que Apache Kafka e Node.js estejam instalados em seu sistema. Você pode instalar Kafka e Node.js seguindo os seguintes artigos:

• Introdução ao Node.js
• Introdução ao Apache Kafka
• Como integrar o Apache Kafka ao Node.js

Instale a biblioteca cliente Kafka Node.js

Para conectar Node.js com Kafka, você pode usar a biblioteca kafkajs, um cliente Kafka popular para Node.js.

npm install kafkajs

Crie um produtor Kafka em Node.js

Em uma arquitetura de microsserviços, um produtor Kafka é responsável por enviar mensagens para um tópico Kafka. Abaixo está um exemplo simples de como criar um produtor Kafka em Node.js:

const { Kafka } = require('kafkajs');

const kafka = new Kafka({
  clientId: 'my-producer',
  brokers: ['localhost:9092']
});

const producer = kafka.producer();

const sendMessage = async () => {
  await producer.connect();
  await producer.send({
    topic: 'my-topic',
    messages: [
      { value: 'Hello Kafka' },
    ],
  });
  await producer.disconnect();
};

sendMessage().catch(console.error);

Crie um consumidor Kafka em Node.js

Um consumidor Kafka é usado para ler mensagens de um tópico Kafka. Veja como você pode criar um consumidor:

const { Kafka } = require('kafkajs');

const kafka = new Kafka({
  clientId: 'my-consumer',
  brokers: ['localhost:9092']
});

const consumer = kafka.consumer({ groupId: 'my-group' });

const runConsumer = async () => {
  await consumer.connect();
  await consumer.subscribe({ topic: 'my-topic', fromBeginning: true });

  await consumer.run({
    eachMessage: async ({ topic, partition, message }) => {
      console.log({
        partition,
        offset: message.offset,
        value: message.value.toString(),
      });
    },
  });
};

runConsumer().catch(console.error);

Estudo de caso

Para ilustrar a integração de Kafka e Node.js em uma arquitetura de microsserviços, considere o seguinte estudo de caso:

Cenário

Temos dois microsserviços:

1. Serviço de pedidos: Lida com os pedidos dos clientes.
2. Serviço de produto: Gerencia estoques de produtos.

Sempre que ocorrer uma compra ou transação no Serviço de Pedidos, o estoque será atualizado no Serviço de Produtos. Kafka facilita essa comunicação agindo como um corretor de mensagens.

Implementação

1. Serviço de pedidos: Publica eventos de pedidos no tópico de atualizações de produtos.
2. Serviço de inventário: Consome mensagens do tópico de atualizações de produtos e atualiza o inventário adequadamente.

Script do produtor de serviço de pedido

O Serviço de Pedidos é responsável pelo tratamento dos pedidos de compra e envio de mensagens ao Serviço de Produtos para atualização do estoque. Veja como você pode implementar o Serviço de Pedido como um produtor Kafka:

// orderService.js
const express = require('express');
const { Kafka } = require('kafkajs');

// Kafka producer configuration
const kafka = new Kafka({
  clientId: 'order-service',
  brokers: ['localhost:9092'],
});

const producer = kafka.producer();

// Initialize Express app
const app = express();
app.use(express.json());

const placeOrder = async (orderId, productId, quantity) => {
  await producer.connect();
  const orderEvent = {
    orderId,
    productId,
    quantity,
    eventType: 'ORDER_PLACED',
    timestamp: Date.now(),
  };
  await producer.send({
    topic: 'product-updates',
    messages: [{ value: JSON.stringify(orderEvent) }],
  });
  await producer.disconnect();
  console.log(`Order placed: ${orderId} for product: ${productId}`);
};

// API endpoint to place an order
app.post('/order', async (req, res) => {
  const { orderId, productId, quantity } = req.body;

  if (!orderId || !productId || !quantity) {
    return res.status(400).json({ error: 'Missing orderId, productId, or quantity' });
  }

  try {
    await placeOrder(orderId, productId, quantity);
    res.status(200).json({ message: `Order ${orderId} placed successfully.` });
  } catch (error) {
    console.error('Error placing order:', error);
    res.status(500).json({ error: 'Failed to place order' });
  }
});

// Start the server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Order Service API running on port ${PORT}`);
});

Script do consumidor de serviço de produto

O Product Service consome mensagens do tópico Kafka de atualizações de produtos e atualiza o estoque do produto de acordo. Aqui está a implementação:

// productService.js
const express = require('express');
const { Kafka } = require('kafkajs');

// Kafka consumer configuration
const kafka = new Kafka({
  clientId: 'product-service',
  brokers: ['localhost:9092'],
});

const consumer = kafka.consumer({ groupId: 'product-group' });

// Initialize Express app
const app = express();
app.use(express.json());

const updateStock = async () => {
  await consumer.connect();
  await consumer.subscribe({ topic: 'product-updates', fromBeginning: true });

  await consumer.run({
    eachMessage: async ({ topic, partition, message }) => {
      const orderEvent = JSON.parse(message.value.toString());
      console.log(`Received order: ${orderEvent.orderId}, Product: ${orderEvent.productId}, Quantity: ${orderEvent.quantity}`);

      // Simulate stock update
      console.log(`Updating stock for product: ${orderEvent.productId}`);
      // logic to update stock
    },
  });
};

// Start the Product Service to listen for messages
updateStock().catch(console.error);

// Start the server
const PORT = process.env.PORT || 3001;
app.listen(PORT, () => {
  console.log(`Product Service API running on port ${PORT}`);
});

Inicie o Product Service primeiro, pois ele precisa ouvir as mensagens recebidas:

node productService.js

O Product Service começará a escutar na porta 3001 (ou em outra porta, se especificada).

Inicie o Serviço de Pedido com este comando:

node orderService.js

O Serviço de Pedido estará disponível na porta 3000 (ou em outra porta, se especificado).

Você pode fazer um pedido enviando uma solicitação POST para a API do Serviço de Pedido:

curl -X POST http://localhost:3000/order \
-H "Content-Type: application/json" \
-d '{
  "orderId": "order-789",
  "productId": "product-123",
  "quantity": 5
}'

Quando um pedido é feito, o Serviço de Pedido enviará uma mensagem Kafka, e o Serviço de Produto consumirá essa mensagem para atualizar o estoque:

Received order: order-789, Product: product-123, Quantity: 5
Updating stock for product: product-123

Conclusão

Integrar Apache Kafka e Node.js em sua arquitetura de microsserviços permite que você crie aplicativos orientados a eventos altamente escaláveis ​​e resilientes.

Seguindo as práticas recomendadas e aproveitando os recursos poderosos do Kafka, você pode processar dados em tempo real com eficiência e criar uma camada de comunicação robusta entre seus microsserviços.