Node.js é conhecido por sua velocidade e eficiência, tornando-o uma escolha popular para a criação de aplicativos escaláveis ​​e de alto desempenho.
No entanto, pronto para uso, Node.js é de thread único, o que significa que ele é executado em um único núcleo de CPU, o que pode ser limitante em ambientes de servidores multi-core. Se seu aplicativo consome muitos recursos ou você espera alto tráfego, você desejará maximizar o uso dos núcleos de CPU do seu servidor.
É aí que entra o clustering Node.js.

Nesta postagem, vamos nos aprofundar em o que é clustering Node.js, por que ele é importante e como você pode usá-lo para aumentar o desempenho de seus aplicativos.

O que é clustering Node.js?

Clustering Node.js é uma técnica que permite utilizar todos os núcleos da CPU gerando várias instâncias (trabalhadores) de seu aplicativo Node.js.
Esses trabalhadores compartilham a mesma porta e são gerenciados por um processo mestre. Cada trabalhador pode lidar com solicitações recebidas de forma independente, permitindo que seu aplicativo distribua a carga de trabalho e processe solicitações em paralelo.

Ao agrupar seu aplicativo Node.js em cluster, você pode:

• Utilize vários núcleos de CPU
• Melhorar o desempenho do aplicativo
• Oferece tolerância a falhas no caso de um trabalhador travar
• Escale horizontalmente sem complicar demais a base de código

Como funciona o agrupamento?

Em um cluster Node.js, há um processo mestre que controla vários processos trabalhadores.
O processo mestre não trata diretamente das solicitações HTTP, mas gerencia os trabalhadores que o fazem. As solicitações dos clientes são distribuídas entre esses trabalhadores, equilibrando a carga de forma eficiente.

Se um processo de trabalho travar por algum motivo, o processo mestre pode gerar um novo, garantindo um tempo de inatividade mínimo.

Quando você deve usar clustering?

O clustering é particularmente útil quando seu aplicativo:

• Experimenta alto tráfego e precisa lidar com inúmeras solicitações simultâneas
• Executa tarefas vinculadas à CPU, como codificação de vídeo, processamento de imagens ou análise de dados em grande escala.
• Funciona em processadores multi-core que não estão sendo totalmente utilizados Se seu aplicativo gastar muito tempo aguardando operações de E/S, como consultas de banco de dados ou chamadas de API, o clustering poderá não melhorar significativamente o desempenho.

Nos casos acima, você pode melhorar o rendimento usando técnicas de programação assíncrona.

Como implementar clustering em Node.js

Node.js fornece um módulo de cluster integrado para criar clusters facilmente. Vejamos um exemplo simples de como agrupar seu aplicativo Node.js.

Etapa 1: Configurando seu aplicativo
Antes de adicionar clustering, vamos supor que você tenha um servidor HTTP simples (server.js):

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200);
  res.end('Hello World\n');
});

server.listen(3000, () => {
  console.log(`Worker process ID: ${process.pid} is listening on port 3000`);
});

Este aplicativo é executado em um único núcleo. Vamos modificá-lo para usar clustering.

Etapa 2: usando o módulo cluster
O módulo cluster nos permite dividir o processo atual em vários processos de trabalho. Veja como implementar clustering:

const cluster = require('cluster');
const http = require('http');
const os = require('os');

// Get the number of CPU cores
const numCPUs = os.cpus().length;

if (cluster.isMaster) {
  console.log(`Master process ID: ${process.pid}`);

  // Fork workers for each CPU core
  for (let i = 0; i  {
    console.log(`Worker ${worker.process.pid} died. Spawning a new one...`);
    cluster.fork();
  });
} else {
  // Workers share the same TCP connection
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('Hello from worker '   process.pid   '\n');
  }).listen(3000);

  console.log(`Worker process ID: ${process.pid}`);
}

Explicação:
1. Processo Mestre: Quando o processo é iniciado, verifica se é o processo mestre (cluster.isMaster). O mestre é responsável por bifurcar processos de trabalho, um para cada núcleo da CPU. O método os.cpus() é usado para recuperar o número de núcleos de CPU disponíveis.

2. Processos de trabalho: Para cada núcleo da CPU, um novo trabalhador é bifurcado (cluster.fork()). Esses processos de trabalho executam o servidor HTTP e lidam com solicitações recebidas.

3. Tolerância a falhas: Se um processo de trabalho travar, o evento cluster.on('exit') é acionado e um novo trabalhador é gerado para substituir o morto.

Etapa 3: Testando seu aplicativo em cluster
Agora, se você executar o aplicativo:

node server.js

Você notará que vários trabalhadores são criados, cada um com um ID de processo exclusivo. Cada solicitação é tratada por um trabalhador diferente, equilibrando efetivamente a carga.

Você pode testar como o clustering melhora o desempenho do seu aplicativo enviando várias solicitações e observando como a carga de trabalho é distribuída entre os trabalhadores.

Então, da próxima vez que você estiver construindo um aplicativo Node.js de alto desempenho, lembre-se de considerar o clustering!

Isso é tudo por este blog! Fique ligado para mais atualizações e continue criando aplicativos incríveis! ?✨
Boa codificação! ?