1. \u2018spawn\u2019():<\/strong> Launches a new process and provides streams for communication.<\/p>\n 2. \u2018exec\u2019():<\/strong> Executes a command in a shell, buffers the output, and provides it in a callback.<\/p>\n 3. \u2018fork\u2019():<\/strong> Creates a child process that communicates with the parent process through IPC (inter-process communication) using message events and send function.<\/p>\n The \u2018exec()\u2019 method in the \u2018child_process\u2019 module of Node.js has several parameters that allow you to customize the behavior of the executed command. Here are the parameters used in the \u2018exec()\u2019 method:<\/p>\n 1. \u2018command\u2019 (string):<\/strong> The command to be executed in a shell.<\/p>\n 2. \u2018options\u2019 (object, optional):<\/strong> An object that allows you to specify additional options for executing the command.<\/p>\n 3. \u2018callback\u2019 (function):<\/strong> A callback function that is invoked when the command execution is complete. It receives three arguments: \u2018error\u2019, \u2018stdout\u2019, and \u2018stderr\u2019.<\/p>\n The \u2018exec()\u2019 method executes the \u2018ls -l\u2019 command, and the callback function handles the results, including any errors, stdout, and stderr.<\/p>\n Output:<\/strong><\/p>\n total 20 Another Example:-<\/strong><\/p>\n Support.js<\/p>\n Master.js<\/p>\n execute the master code and the output will be [node master.js]:-<\/strong><\/p>\n The \u2018spawn()\u2019 method in the \u2018child_process\u2019 module of Node.js provides several parameters to customize the behavior of the spawned child process. Here are the parameters used in the \u2018spawn()\u2019 method:<\/p>\n 1. \u2018command\u2019 (string):<\/strong> The command to be executed. It should be the name or path of the executable.<\/p>\n 2. \u2018args\u2019 (array, optional):<\/strong> An array of command-line arguments to be passed to the command.<\/p>\n 3. \u2018options\u2019 (object, optional):<\/strong> An object that allows you to specify additional options for spawning the child process.<\/p>\n The \u2018spawn()\u2019 method spawns a child process with the command ‘ls’ and the argument [‘-l’]. The child process’s output is captured through \u2018stdout\u2019 and \u2018stderr\u2019 events, and the \u2018close\u2019 event is triggered when the child process exits.<\/p>\n Another Example:-<\/strong><\/p>\n Support.js<\/p>\n Master.js<\/p>\n execute the master code and the output will be [node master.js]:-<\/strong><\/p>\n The \u2018fork()\u2019 method in the \u2018child_process\u2019 module of Node.js has several parameters that allow you to configure the behavior of the forked child process. Here are the parameters used in the \u2018fork()\u2019 method:<\/p>\n 1. \u2018modulePath\u2019 (string):<\/strong> The path to the module file that will be executed as the child process.<\/p>\n 2. \u2018args\u2019 (array, optional):<\/strong> An array of command-line arguments to be passed to the module.<\/p>\n 3. \u2018options\u2019 (object, optional):<\/strong> An object that allows you to specify additional options for forking the child process.<\/p>\n In this example, the \u2018fork()\u2019 method creates a child process that executes the \u2018child.js\u2019 module. The parent process communicates with the child process using the \u2018message\u2019 event and the \u2018send()\u2019 function.<\/p>\n Another Example:-<\/strong><\/p>\n Support.js<\/p>\n Master.js<\/p>\n execute the master code, and the output will be [node master.js]:-<\/strong><\/p>\n We will create the directory for the project and download the dependencies for the application which we will be creating here:<\/p>\n Make a directory first to start. You can give the directory any name you like, such as the cluster_demo:<\/p>\n Enter the directory after that:<\/p>\n The project must then be initialised in order to produce a package.the json file<\/p>\n NPM is instructed to accept all default options by the -y option.<\/p>\n The command will produce output that complies with the following when it runs:<\/p>\n Take note of the following characteristics that relate to your particular project:<\/strong><\/p>\n name:<\/strong> The npm package’s name.<\/p>\n version:<\/strong> The version of your package.<\/p>\n main:<\/strong> the point at which your project begins.<\/p>\n Next, launch your preferred editor (nano will be used in this tutorial) and open the package.json file:<\/p>\n Add the italicised text to your package.json file to enable support for ES modules when importing packages:<\/p>\n Save and close the file<\/p>\n You will then download the following files:<\/p>\n express is a Node.js framework for creating web applications.js.<\/p>\n An app’s performance can be evaluated by creating traffic with the help of the loadtest tool.<\/p>\n PM2 is a programme that scales apps to use multiple CPUs automatically.<\/p>\n For the Express package to download, enter the following command:<\/p>\n Run the following command to download PM2 and loadtest globally next:<\/p>\n After setting up the required dependencies, you will now create an application without using clustering.<\/p>\n There are several strategies that can be employed to effectively handle increasing workloads and user demands. Here, I’ll explain three strategies: cloning, decomposing, and splitting.<\/p>\n 1. Cloning:-<\/strong> Cloning is the process of making exact replicas of a service or application in order to handle the increased load. Because the load is shared equally among the clones, capacity is increased, and performance is improved. Cloning can be done by creating duplicate instances of an application using containerization technologies like Docker or by replicating entire servers or virtual machines. Incoming requests can then be split among these clones by load balancers, ensuring optimum resource use.<\/p>\n 2. Decomposing:-<\/strong> Another technique for scalability is to decompose, or break down, an application into smaller, independent components or services. Using this strategy, which is frequently used in conjunction with a microservices architecture, a monolithic application is divided into modular services that can be created, deployed, and scaled independently. Each service specialises in a particular functionality or industry, allowing teams to work on them independently. Microservices enable more effective scaling because they can each be scaled independently based on their unique demand, optimising resource allocation and enhancing overall performance.<\/p>\n 3. Splitting:-<\/strong> Splitting is the process of distributing the workload among various systems or resources. It entails segmenting various components of an application or its data in order to spread the load and improve scalability. For instance, splitting can take the form of sharding in the context of a database, where data is horizontally divided across several database instances or servers based on particular criteria (such as user ID or geographic region). The ability of each shard to handle a portion of the total data enables parallel processing and enhances performance. In a similar vein, splitting can also entail dividing up functionality or tasks across several servers or services to prevent bottlenecks and allow for independent scaling of different components.<\/p>\n Based on the unique needs and architectural design of an application, these cloning, decomposing, and splitting strategies offer various ways to achieve scalability. They enable flexible system scaling both horizontally and vertically, maximise resource efficiency, and guarantee effective management of growing workloads. The best strategy to use, or a combination of strategies, will depend on a number of variables, including the application’s nature, expected growth, performance requirements, and available resources.<\/p>\n A cluster of child processes also referred to as worker processes, can be created and managed using the cluster module, a built-in module in Node.js. It offers a simple method to take advantage of multiple CPU cores, enhancing the performance and scalability of Node.js applications.<\/p>\n The cluster module’s primary function is to make it possible to distribute incoming network connections and requests among several workers, enabling the application to support more concurrent connections. This is accomplished by setting up a group of child processes that share a server port. Each child process functions as a separate instance of the application, able to respond to requests and execute parallel programs.<\/p>\n Here are the key features and components of the cluster module:<\/strong><\/p>\n 1. Master Process:<\/strong> Initiating and overseeing worker processes is the responsibility of the master process. It keeps an ear out for network connections and divides them up between the workers using different algorithms, like round-robin or the least-connection technique.<\/p>\n 2. Worker Processes:<\/strong> The master process generates worker processes. With its own event loop and memory space, each worker runs as a distinct instance of the application. They can each manage incoming requests independently while sharing the same server port.<\/p>\n 3. Load Balancing:<\/strong> To fairly distribute network connections across the available worker processes, the cluster module employs an internal load balancing mechanism. This aids in making the most of multi-core systems’ capabilities and handling heavier concurrent loads.<\/p>\n 4.Inter-Process Communication (IPC):<\/strong> IPC channels are used by the master and worker processes to communicate. By enabling message transfer between the master and workers, the IPC facilitates data sharing, action coordination, and operation synchronisation.<\/p>\n You may extend your application horizontally and utilise all of the CPU cores available by using the cluster module to handle additional traffic and boost performance. The module offers a simple and effective approach to constructing a clustered Node.js application by abstracting away the complexities of maintaining many processes, load balancing, and inter-process communication.<\/p>\n Here’s a simple example demonstrating the usage of the cluster module:<\/strong><\/p>\n In this case, the master process uses a cluster. fork() to establish numerous worker processes, each of which manages incoming HTTP requests individually. When a worker process terminates, the master process forks a new worker to take its place. The cluster module automatically manages the load balancing, enabling the application to effectively handle more concurrent requests.<\/p>\nThe exec() method:<\/h3>\n
\n
const { exec } = require('child_process');\n \nexec('ls -l', (error, stdout, stderr) => {\n if (error) {\n console.error(`Error: ${error.message}`);\n return;\n }\n \n if (stderr) {\n console.error(`Error: ${stderr}`);\n return;\n }\n \n console.log(`Output: ${stdout}`);\n});\n<\/pre>\n
\ndrwxr-xr-x 2 user staff 64 May 20 10:15 directory1
\n-rw-r–r– 1 user staff 116 May 20 10:15 file1.txt
\n-rw-r–r– 1 user staff 120 May 20 10:15 file2.txt<\/p>\nconsole.log(\"Child Process \" + process.argv[2] + \" executed.\" );\n<\/pre>\n
const fs = require('fs');\nconst child_process = require('child_process');\n\nfor(var i=0; i<3; i++) {\n var workerProcess = child_process.exec('node support.js '+i,function \n (error, stdout, stderr) {\n \n if (error) {\n console.log(error.stack);\n console.log('Error code: '+error.code);\n console.log('Signal received: '+error.signal);\n }\n console.log('stdout: ' + stdout);\n console.log('stderr: ' + stderr);\n });\n\n workerProcess.on('exit', function (code) {\n console.log('Child process exited with exit code '+code);\n });\n}\n\n<\/pre>\nChild process exited with exit code 0\nstdout: Child Process 1 executed.\n\nstderr:\nChild process exited with exit code 0\nstdout: Child Process 0 executed.\n\nstderr:\nChild process exited with exit code 0\nstdout: Child Process 2 executed.\n<\/pre>\n
The spawn() Method:<\/h3>\n
\n
const { spawn } = require('child_process');\n \nconst child = spawn('ls', ['-l']);\n \nchild.stdout.on('data', (data) => {\n console.log(`Output: ${data}`);\n});\n \nchild.stderr.on('data', (data) => {\n console.error(`Error: ${data}`);\n});\n \nchild.on('close', (code) => {\n console.log(`Child process exited with code ${code}`);\n});\n<\/pre>\nconsole.log(\"Child Process \" + process.argv[2] + \" executed.\" );\n<\/pre>\n
const fs = require('fs');\nconst child_process = require('child_process');\n \nfor(var i = 0; i<3; i++) {\n var workerProcess = child_process.spawn('node', ['support.js', i]);\n\n workerProcess.stdout.on('data', function (data) {\n console.log('stdout: ' + data);\n });\n\n workerProcess.stderr.on('data', function (data) {\n console.log('stderr: ' + data);\n });\n\n workerProcess.on('close', function (code) {\n console.log('child process exited with code ' + code);\n });\n}\n<\/pre>\nstdout: Child Process 0 executed.\n\nchild process exited with code 0\nstdout: Child Process 1 executed.\n\nstdout: Child Process 2 executed.\n\nchild process exited with code 0\nchild process exited with code 0\n<\/pre>\n
The fork() Method:<\/h3>\n
\n
const { fork } = require('child_process');\n \nconst child = fork('child.js');\n \nchild.on('message', (message) => {\n console.log(`Received message from child process: ${message}`);\n});\n \nchild.send('Hello, child process!');\n<\/pre>\nconsole.log(\"Child Process \" + process.argv[2] + \" executed.\" );\n<\/pre>\n
const fs = require('fs');\nconst child_process = require('child_process');\n \nfor(var i=0; i<3; i++) {\n var worker_process = child_process.fork(\"support.js\", [i]);\t\n\n worker_process.on('close', function (code) {\n console.log('child process exited with code ' + code);\n });\n}\n<\/pre>\nChild Process 0 executed.\nChild Process 1 executed.\nChild Process 2 executed.\nchild process exited with code 0\nchild process exited with code 0\nchild process exited with code 0\n<\/pre>\n
Setting Up The Project Directory [Setup]<\/h3>\n
mkdir cluster_demo\n<\/pre>\n
cd cluster_demo\n<\/pre>\n
npm init -y\n<\/pre>\n
Output\nWrote to \/home\/sammy\/cluster_demo\/package.json:\n\n{\n \"name\": \"cluster_demo\",\n \"version\": \"1.0.0\",\n \"description\": \"\",\n \"main\": \"index.js\",\n \"scripts\": {\n \"test\": \"echo \\\"Error: no test specified\\\" && exit 1\"\n },\n \"keywords\": [],\n \"author\": \"\",\n \"license\": \"ISC\"\n}\n<\/pre>\nnano package.json,\n<\/pre>\n
{\n ...\n \"author\": \"\",\n \"license\": \"ISC\",\n \"type\": \"module\"\n}\n<\/pre>\nnpm install express\n<\/pre>\n
npm install -g loadtest pm2\n<\/pre>\n
Strategies of Scalability<\/h3>\n
Cluster Module<\/h3>\n
const cluster = require('cluster');\nconst http = require('http');\nconst numCPUs = require('os').cpus().length;\n\nif (cluster.isMaster) {\n console.log(`Master ${process.pid} is running`);\n\n \/\/ Fork workers\n for (let i = 0; i < numCPUs; i++) {\n cluster.fork();\n }\n\n \/\/ Handle worker events\n cluster.on('exit', (worker, code, signal) => {\n console.log(`Worker ${worker.process.pid} died`);\n \/\/ Replace the dead worker\n cluster.fork();\n });\n} else {\n \/\/ Worker process - create an HTTP server\n http.createServer((req, res) => {\n res.writeHead(200);\n res.end('Hello, World!');\n }).listen(8000);\n\n console.log(`Worker ${process.pid} started`);\n}\n<\/pre>\n
![\"Scaling](\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/sites\/2\/2023\/08\/Scaling-Application.webp\")
<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"