Módulo Cluster
O Módulo Cluster no Node.js é uma ferramenta avançada para otimizar a utilização de múltiplos núcleos de CPU em aplicações Node.js. Por padrão, o Node.js opera em um único loop de eventos, o que pode limitar a performance em servidores de alta carga ou aplicações que realizam cálculos intensivos. O Cluster permite criar múltiplos processos Worker que executam em paralelo, cada um com seu próprio loop de eventos, enquanto um processo Master gerencia e monitora esses Workers. Isso aumenta significativamente o throughput, reduz a latência e melhora a escalabilidade do sistema.
O Módulo Cluster é especialmente útil em servidores web, APIs em tempo real e serviços que demandam processamento paralelo. Ele permite que os desenvolvedores iniciem, monitorem e reiniciem Workers quando necessário, garantindo resiliência e continuidade do serviço. Conceitos fundamentais do Node.js, como sintaxe, estruturas de dados, algoritmos e princípios de OOP, são aplicados neste módulo para criar sistemas robustos e escaláveis.
Neste tutorial, o leitor aprenderá a criar e gerenciar processos Master e Worker, implementar balanceamento de carga, tratar erros de forma eficiente e otimizar recursos do sistema. A compreensão profunda do Módulo Cluster habilita o desenvolvimento de aplicações Node.js de alto desempenho, tolerantes a falhas e prontas para ambientes de produção.
Exemplo Básico
textconst cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;
if (cluster.isMaster) {
console.log(`Master PID ${process.pid} está rodando`);
for (let i = 0; i < numCPUs; i++) {
cluster.fork();
}
cluster.on('exit', (worker, code, signal) => {
console.log(`Worker PID ${worker.process.pid} morreu. Reiniciando...`);
cluster.fork();
});
} else {
http.createServer((req, res) => {
res.writeHead(200);
res.end(`Olá do Worker PID ${process.pid}\n`);
}).listen(8000);
console.log(`Worker PID ${process.pid} iniciado`);
}Neste exemplo básico, cluster.isMaster verifica se o processo atual é o Master. O Master cria Workers iguais ao número de núcleos da CPU, permitindo que cada Worker processe requisições HTTP de forma independente e paralela. O evento cluster.on('exit') monitora a finalização de qualquer Worker e reinicia automaticamente o processo, garantindo disponibilidade contínua. O process.pid identifica os processos de forma única. Este exemplo demonstra os conceitos fundamentais do Módulo Cluster e ilustra como otimizar desempenho sem comprometer a estabilidade.
Exemplo Prático
textconst cluster = require('cluster');
const http = require('http');
const os = require('os');
class WorkerManager {
constructor() {
this.numCPUs = os.cpus().length;
this.workers = [];
}
start() {
if (cluster.isMaster) {
console.log(`Master PID ${process.pid} está rodando`);
for (let i = 0; i < this.numCPUs; i++) {
this.createWorker();
}
cluster.on('exit', (worker, code, signal) => {
console.log(`Worker PID ${worker.process.pid} morreu. Reiniciando...`);
this.createWorker();
});
} else {
this.createServer();
}
}
createWorker() {
const worker = cluster.fork();
this.workers.push(worker);
}
createServer() {
const server = http.createServer((req, res) => {
const start = Date.now();
while (Date.now() - start < 100) {} // simula carga de CPU
res.writeHead(200);
res.end(`Worker PID ${process.pid} processou a requisição\n`);
});
server.listen(8000, () => {
console.log(`Worker PID ${process.pid} escutando na porta 8000`);
});
}
}
const manager = new WorkerManager();
manager.start();Neste exemplo avançado, a classe WorkerManager gerencia todos os processos e servidores Worker utilizando princípios de OOP. O Master monitora todos os Workers e os reinicia caso algum falhe. Cada Worker processa requisições HTTP simulando uma carga de CPU, demonstrando paralelismo real. Este exemplo aplica algoritmos eficientes, boas práticas de tratamento de erro e otimização de performance, oferecendo um modelo robusto para aplicações Node.js escaláveis.
Melhores práticas e erros comuns ao usar o Módulo Cluster:
- Ajustar o número de Workers de acordo com os núcleos da CPU.
- Monitorar e reiniciar Workers em caso de falha.
- Gerenciar corretamente recursos compartilhados, como conexões de banco de dados.
- Implementar tratamento de erros em cada Worker.
- Evitar bloqueio do event loop com operações síncronas pesadas.
- Validar entradas e garantir segurança na comunicação IPC.
Seguindo estas práticas, é possível construir aplicações Node.js confiáveis, escaláveis e de alta performance.
📊 Tabela de Referência
| Node.js Element/Concept | Description | Usage Example |
|---|---|---|
| cluster.isMaster | Verifica se o processo atual é Master | if (cluster.isMaster) { ... } |
| cluster.fork() | Cria um novo processo Worker | const worker = cluster.fork(); |
| cluster.on('exit') | Reinicia Worker quando termina | cluster.on('exit', (worker)=>{ cluster.fork(); }); |
| process.pid | Identifica o PID do processo | console.log(process.pid); |
| http.createServer | Cria servidor HTTP em cada Worker | http.createServer((req,res)=>{res.end('ok')}).listen(8000); |
Dominar o Módulo Cluster permite aproveitar ao máximo os núcleos de CPU, gerenciar processos, lidar com falhas e criar sistemas escaláveis. Próximos passos recomendados incluem estudar Worker Threads, otimização de IPC, monitoramento de memória e técnicas avançadas de balanceamento de carga. A documentação oficial do Node.js e projetos open-source são excelentes recursos para aprofundamento.
🧠 Teste Seu Conhecimento
Teste Seu Conhecimento
Desafie-se com este questionário interativo e veja o quão bem você entende o tópico
📝 Instruções
- Leia cada pergunta cuidadosamente
- Selecione a melhor resposta para cada pergunta
- Você pode refazer o quiz quantas vezes quiser
- Seu progresso será mostrado no topo