Neste artigo, você vai aprender como escalar aplicações Node.js de forma prática, utilizando essas duas abordagens, além de entender quando e como aplicá-las no seu projeto.

O desafio da escalabilidade em Node.js

Escalando com Clusters no Node.js

O que são Clusters?

Balanceamento de carga e estratégias

• Round-Robin: atribui requisições sequencialmente a cada worker, de forma cíclica. É simples e funciona bem na maioria dos cenários.

• IP Hashing: as requisições são encaminhadas ao worker com base no endereço IP do cliente. Essa estratégia garante que o mesmo cliente seja sempre atendido pelo mesmo worker, sendo útil em cenários que exigem afinidade de sessão.

• Menos Conexões (Least Connections): a requisição é encaminhada ao worker com o menor número de conexões ativas no momento. Esse método busca equilibrar a carga dinamicamente.

Como funciona?

Implementando Clusters

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

if (cluster.isMaster) {
  const numCPUs = os.cpus().length;
  console.log(`Master ${process.pid} is running`);

  // Cria um worker para cada CPU disponível
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on("exit", (worker) => {
    console.log(`Worker ${worker.process.pid} died. Reiniciando...`);
    cluster.fork();
  });
} else {
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`Handled by worker ${process.pid}`);
  }).listen(8000);

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

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

// Função simulando uma tarefa complexa (ex: processamento de imagem ou query pesada)
function heavyTask() {
  // Simula um atraso de 200ms
  const start = Date.now();
  while (Date.now() - start < 200) {
    // Loop para simular carga de CPU
  }
  return "Tarefa complexa concluída!";
}

if (cluster.isMaster) {
  const numCPUs = os.cpus().length;
  console.log(`Master ${process.pid} is running`);

  // Cria um worker por CPU
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  // Reinicia o worker em caso de falha
  cluster.on("exit", (worker) => {
    console.log(`Worker ${worker.process.pid} died. Reiniciando...`);
    cluster.fork();
  });
} else {
  // Servidor HTTP que simula uma operação complexa antes de responder
  http.createServer((req, res) => {
    const result = heavyTask();
    res.writeHead(200, { "Content-Type": "text/plain" });
    res.end(`Handled by worker ${process.pid}\n${result}`);
  }).listen(8000);

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

Limitações

O poder do paralelismo com Worker Threads

Quando usar?

• Processamento de dados em larga escala.

• Compressão e descompressão de arquivos.

• Criptografia.

• Cálculos matemáticos complexos.

• Aplicação de filtros em imagens.

Implementando Worker Threads

const { Worker, isMainThread, parentPort, workerData } = require("worker_threads");

if (isMainThread) {
  const worker = new Worker(__filename, { workerData: 10 });

  worker.on("message", (result) => {
    console.log(`Result from worker: ${result}`);
  });

  worker.on("error", (error) => {
    console.error(`Worker error: ${error}`);
  });

  worker.on("exit", (code) => {
    if (code !== 0) {
      console.error(`Worker stopped with exit code ${code}`);
    }
  });
} else {
  const computeFactorial = (n) => (n <= 1 ? 1 : n * computeFactorial(n - 1));
  parentPort.postMessage(computeFactorial(workerData));
}

Implementando Worker Threads

// workerTask.js
const { parentPort, workerData } = require("worker_threads");
const { applyFilterToImage } = require("./imageFilter"); // Função fictícia de filtro

// workerData seria um objeto com { imageBuffer: <Buffer da imagem> }
const result = applyFilterToImage(workerData.imageBuffer);
parentPort.postMessage(result);

// main.js
const { Worker, isMainThread } = require("worker_threads");
const fs = require("fs");

if (isMainThread) {
  // Suponha que temos várias imagens para processar
  const imageFiles = ["img1.jpg", "img2.jpg", "img3.jpg"];

  imageFiles.forEach((file) => {
    const imageBuffer = fs.readFileSync(file);

    const worker = new Worker("./workerTask.js", {
      workerData: { imageBuffer },
    });

    worker.on("message", (filteredImage) => {
      // Salva a imagem filtrada
      fs.writeFileSync(`filtered-${file}`, filteredImage);
      console.log(`Imagem ${file} filtrada com sucesso!`);
    });

    worker.on("error", (err) => {
      console.error(`Erro no Worker ao processar ${file}:`, err);
    });

    worker.on("exit", (code) => {
      if (code !== 0) console.error(`Worker finalizado com código de saída ${code}`);
    });
  });
}

Vantagens dos Worker Threads

• Execução paralela de tarefas intensivas de CPU.

• Redução de overhead comparado a criar novos processos.

• Compartilhamento de memória entre threads com SharedArrayBuffer.

Desafios

• Gerenciamento de sincronização entre threads.

• Evitar condições de corrida e deadlocks.

Clusters vs. Worker Threads: qual escolher?

Combinando Clusters e Worker Threads

const cluster = require("cluster");
const os = require("os");
const { Worker } = require("worker_threads");

if (cluster.isMaster) {
  const numCPUs = os.cpus().length;
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  require("./server"); // Código do servidor com Worker Threads
}

Conclusão

• Acompanhamento personalizado por tutores.

• Certificado validado pelo mercado.

• Uma comunidade vibrante para networking e troca de experiências.

• Aulas práticas ministradas por Diego Fernandes, especialista e CTO da Rocketseat.