¿Cómo ejecutar muchas requests HTTP paralelas usando Node.js?

Sabemos que la aplicación NodeJS es de un solo subproceso. Digamos que si el procesamiento implica la solicitud A que demora 10 segundos, no significa que una solicitud que viene después de esta solicitud deba esperar 10 segundos para comenzar a procesarse porque los bucles de eventos de NodeJS son solo de un solo subproceso. Toda la arquitectura de NodeJS no es de un solo subproceso. 

¿Cómo maneja NodeJS múltiples requests de clientes?

NodeJS recibe varias requests de clientes y las coloca en EventQueue . NodeJS está construido con el concepto de arquitectura basada en eventos. NodeJS tiene su propio EventLoop, que es un bucle infinito que recibe requests y las procesa. EventLoop es el oyente de EventQueue. 

Si NodeJS puede procesar la solicitud sin bloqueo de E/S, entonces el bucle de eventos procesaría la solicitud y enviaría la respuesta al cliente por sí mismo. Sin embargo, es posible procesar varias requests en paralelo utilizando el módulo de clúster de NodeJS o el módulo de trabajo_hilos .

¿Cómo escalar su aplicación NodeJS con Cluster Module? 

Una sola instancia de Node.js se ejecuta en un solo hilo. Si tiene un sistema de varios núcleos, puede utilizar todos los núcleos. A veces, el desarrollador quiere lanzar un clúster de procesos NodeJS para aprovechar el sistema multinúcleo.

El módulo de clúster permite la creación sencilla de procesos secundarios que comparten todos los mismos puertos de servidor.

Paso 1: Cree una aplicación NodeJS e instale el módulo Express.js requerido.

mkdir Project && cd Project
npm init -y 
npm i express

Paso 2: Cree un archivo index.js en su directorio raíz con el siguiente código. 

const express = require('express');
const cluster = require('cluster');
 
// Check the number of available CPU.
const numCPUs = require('os').cpus().length;
 
const app = express();
const PORT = 3000;
 
// For Master process
if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);
 
  // Fork workers.
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
 
  // This event is firs when worker died
  cluster.on('exit', (worker, code, signal) => {
    console.log(`worker ${worker.process.pid} died`);
  });
}
 
// For Worker
else{
 
  // Workers can share any TCP connection
  // In this case it is an HTTP server
  app.listen(PORT, err =>{
    err ?
    console.log("Error in server setup") :
    console.log(`Worker ${process.pid} started`);
  });
}

Explicación: si su sistema tiene 8 CPU, se crearán 8 instancias de NodeJS y cada instancia tiene su propio ciclo de eventos independiente. Ahora NodeJS puede procesar todas las requests en paralelo. 

Todos comparten el mismo puerto (PORT 3000) pero no el estado. El proceso maestro escucha en un puerto, acepta nuevas conexiones y las distribuye entre los trabajadores en forma rotativa, con algunas funciones inteligentes integradas para evitar sobrecargar un proceso de trabajo.

Paso 3: Ejecute el archivo index.js con el siguiente comando.

node index.js

Producción:

Uso del módulo worker_threads: la mejor solución para el rendimiento de la CPU es Worker Thread. Este módulo se usa en Node.js porque es útil para realizar tareas pesadas de JavaScript.

En vez de tener:

• un proceso
• un hilo
• Un bucle de eventos
• Una instancia de motor JS
• Una instancia de Node.js
• Los subprocesos de trabajo tienen:

un proceso

• Múltiples hilos
• Un bucle de eventos por subproceso
• Una instancia de JS Engine por subproceso
• Una instancia de Node.js por subproceso

Ejemplo: Cree un archivo index.js con el siguiente código.

índice.js

const {Worker} = require('worker_threads');
 
const worker = new Worker(__filename);
worker.on('message', message => console.log(message));
 
worker.postMessage('GeeksforGeeks');
worker.emit(true)

Ejecute el servidor con el siguiente comando:

node --experimental-worker index.js

Nota: Tenemos que usar el –experimental-worker porque los módulos Workers Thread aún son experimentales.

Producción:

{ name: ‘GeeksforGeeks’ }

Ventajas de Worker_Threads:

• Pasar identificadores nativos (solicitud http/https)
• Detección de interbloqueo.
• Más aislamiento, por lo que si un proceso se ve afectado, no afectará a otros.

Contras de Worker_Threads:

• No es bueno para las operaciones de E/S.
• La generación de trabajadores no es barata.