Publier un projet

Scaling Distributed Systems: Vertical Scaling, Horizontal Scaling & Auto Scaling

Publié le 1 septembre, 2026 - Dernière modification le 2 septembre, 2026

Scaling is one of the most important concepts in system design. As traffic increases, applications must handle more requests efficiently without crashing or slowing down. This article covers vertical scaling, Node.js clustering, autoscaling strategies, capacity estimation, and queue-based architectures for large-scale applications. <h2>Vertical Scaling</h2> <h3>What is Vertical Scaling?</h3> Vertical scaling means increasing the resources of a single machine to handle higher traffic. This includes: <ul> <li>Increasing CPU power</li> <li>Adding more RAM</li> <li>Upgrading storage</li> <li>Better machine configurations</li> </ul> Example: <pre><code class="language-text">2 CPU + 4GB RAM → 8 CPU + 32GB RAM </code></pre> Vertical scaling is simple to implement but has hardware limitations. <hr /> <h2>Limitation in Node.js</h2> Node.js runs on a single-threaded event loop. This means: <ul> <li>One process typically uses only one CPU core</li> <li>Multi-core CPUs are not fully utilized automatically</li> </ul> In contrast, languages such as: <ul> <li>Go</li> <li>Rust</li> <li>Java</li> </ul> support multithreading and can efficiently utilize multiple CPU cores. <hr /> <h2>A Naive Approach (Incorrect)</h2> A beginner approach might be manually starting multiple Node.js processes: <pre><code class="language-bash">node index.js node index.js node index.js node index.js node index.js node index.js node index.js node index.js </code></pre> <h3>Problems with This Approach</h3> <ol> <li>Difficult process management</li> <li>Port conflicts between processes</li> <li>No built-in load balancing</li> <li>No fault tolerance or auto recovery</li> </ol> <hr /> <h2>Solution: Node.js Cluster Module</h2> Node.js provides a built-in <code>cluster</code> module to use multiple CPU cores. Benefits: <ul> <li>Creates worker processes</li> <li>Uses multiple CPU cores</li> <li>Workers share the same port</li> <li>Requests are distributed automatically</li> </ul> <h3>Application Logic (<code>index.js</code>)</h3> <pre><code class="language-javascript">import express from 'express' export const app = express() console.log(`Worker ${process.pid} started`) app.get('/', (req, res) => { res.send('Hello World!') }) app.get('/api/:n', (req, res) => { let n = parseInt(req.params.n) let count = 0 if (n > 5000000000) { n = 5000000000 } for (let i = 0; i <= n; i++) { count += i } res.send(`Final count is ${count} (handled by PID ${process.pid})`) }) </code></pre> <h3>Cluster Entry (<code>bin.js</code>)</h3> <pre><code class="language-javascript">import cluster from 'cluster' import os from 'os' import { app } from './index.js' const totalCPUs = os.cpus().length const port = 3000 if (cluster.isPrimary) { console.log(`Number of CPUs: ${totalCPUs}`) console.log(`Primary process ${process.pid} is running`) for (let i = 0; i < totalCPUs; i++) { cluster.fork() } cluster.on('exit', worker => { console.log(`Worker ${worker.process.pid} died`) console.log('Restarting worker...') cluster.fork() }) } else { app.listen(port, () => { console.log(`App listening on port ${port}`) }) } </code></pre> <hr /> <h2>Parallel Computation Using Clusters</h2> Heavy CPU tasks can be divided among workers. Instead of one process calculating everything sequentially, the workload is split across multiple CPU cores. <h3>Cluster-Based Parallel Computation</h3> <pre><code class="language-javascript">import cluster from 'cluster' import os from 'os' const numCPUs = os.cpus().length const n = 1_000_000_000 if (cluster.isPrimary) { const chunkSize = Math.floor(n / numCPUs) let completed = 0 let totalSum = 0 const startTime = Date.now() for (let i = 0; i < numCPUs; i++) { const start = i * chunkSize + 1 const end = i === numCPUs - 1 ? n : (i + 1) * chunkSize const worker = cluster.fork() worker.send({ start, end }) worker.on('message', partialSum => { totalSum += partialSum completed++ if (completed === numCPUs) { const endTime = Date.now() console.log('Total Sum:', totalSum) console.log('Execution Time:', endTime - startTime, 'ms') for (const id in cluster.workers) { cluster.workers[id]?.kill() } } }) } } else { process.on('message', ({ start, end }) => { let sum = 0 for (let i = start; i <= end; i++) { sum += i } process.send?.(sum) }) } </code></pre> <h3>Sequential Computation</h3> <pre><code class="language-javascript">const n = 1_000_000_000 let sum = 0 const start = Date.now() for (let i = 1; i <= n; i++) { sum += i } const end = Date.now() console.log('Sum:', sum) console.log('Time:', end - start, 'ms') </code></pre> <hr /> <h2>Capacity Estimation</h2> Before scaling, estimate how much traffic your system must handle. <h3>Step 1: Estimate Requests Per Second (RPS)</h3> Example: <pre><code class="language-text">10,000 users ≈ 100 RPS </code></pre> <hr /> <h3>Step 2: Measure Server Capacity</h3> Benchmark a single machine. Example: <pre><code class="language-text">1 server = 500 RPS </code></pre> <hr /> <h3>Step 3: Estimate Required Machines</h3> Formula: <pre><code class="language-text">Total RPS / RPS per machine </code></pre> Example: <pre><code class="language-text">1000 RPS / 500 = 2 machines </code></pre> <hr /> <h2>Autoscaling Groups (ASGs)</h2> Autoscaling automatically adjusts infrastructure based on demand. Scaling decisions can be based on: <ul> <li>CPU usage</li> <li>Memory usage</li> <li>Traffic spikes</li> <li>Queue length</li> </ul> Benefits: <ul> <li>Saves cost</li> <li>Handles sudden traffic</li> <li>Improves availability</li> </ul> <hr /> <h2>Scaling Complex Applications</h2> For high-scale systems, simple server scaling is often not enough. A queue-based architecture is commonly used. <h3>Architecture Flow</h3> <pre><code class="language-text">Client → Queue → Workers → Database/Storage → Response </code></pre> <hr /> <h2>Queue-Based Processing</h2> Typical flow: <ol> <li>Request arrives</li> <li>Request enters a queue</li> <li>Workers consume tasks</li> <li>Processing happens asynchronously</li> <li>Results are stored</li> </ol> <hr /> <h2>Dynamic Worker Scaling</h2> As load increases: <pre><code class="language-text">More Queue Jobs → More Workers </code></pre> As load decreases: <pre><code class="language-text">Fewer Jobs → Fewer Workers </code></pre> This approach enables efficient horizontal scaling. <hr /> <h2>Benefits of Queue-Based Systems</h2> <ul> <li>Handles high traffic efficiently</li> <li>Prevents server overload</li> <li>Enables horizontal scaling</li> <li>Improves reliability</li> <li>Supports asynchronous workloads</li> </ul> <hr /> <h2>Conclusion</h2> Simple applications often scale using better machines and additional servers. However, large-scale systems rely on clustering, autoscaling, queues, and worker architectures to handle millions of requests efficiently. Understanding when to use vertical scaling, horizontal scaling, or distributed processing is essential for designing reliable systems.

0Mentions j'aime 0 Commentaires

Article suivant

Why Good Design Matters More Than Ever for Small Businesses

par kamrans301 - 31 août, 2026

Scaling Distributed Systems: Vertical Scaling, Horizontal Scaling & Auto Scaling

Pride of Cows: How Parag Milk Foods Built India's First Single-Origin Dairy Brand

How Does a Good SOC Analyst Think?

AI-Assisted Development: The Future of Full-Stack Web Development

What is the Preferred Freelancer Program?

What makes a good profile

Why Your GoHighLevel Automations Break When Connected With Zapier (And How to Fix Them)

Why Good Design Matters More Than Ever for Small Businesses

Scaling Distributed Systems: Vertical Scaling, Horizontal Scaling &amp; Auto Scaling

Articles correspondants

Why Good Design Matters More Than Ever for Small Businesses

Scaling Distributed Systems: Vertical Scaling, Horizontal Scaling & Auto Scaling