chore: continuing with chapter 12

Author: lmammino

12-scalability-and-architectural-patterns/06-http-dynamic-load-balancer/README.md

@@ -0,0 +1,81 @@
+# 06-http-dynamic-load-balancer
+
+This example demonstrates how to implement a dynamic load balancer in Node.js
+using consul as a service discovery mechanism.
+
+## Dependencies
+
+This example requires you to install some third-party dependencies from npm.
+
+If you have `pnpm` installed, you can do that with:
+
+```bash
+pnpm install
+```
+
+Alternatively, if you prefer to use another package manager, make sure to delete
+the `pnpm-lock.yaml` file before using it.
+
+If you want to use `npm`, you can run:
+
+```bash
+npm install
+```
+
+If you want to use `yarn`, you can run:
+
+```bash
+yarn install
+```
+
+You will also need to install Consul following the
+[instructions for your system](https://nodejsdp.link/consul-install), or by
+running:
+
+```bash
+sudo apt-get install consul # on debian / ubuntu based systems
+# or
+brew install consul # on mac with brew installed
+```
+
+## Run
+
+Start the Consul service registry locally:
+
+```bash
+consul agent -dev
+```
+
+Start the load balancer:
+
+```bash
+node loadBalancer.js
+```
+
+If you try to access a service before starting any servers, you'll get a 502
+error:
+
+```bash
+curl localhost:8080/api
+# Output: Bad Gateway
+```
+
+In separate terminals, start your service instances (e.g., two api-service and
+one webapp-service):
+
+```bash
+app.js api-service
+app.js api-service
+app.js webapp-service
+```
+
+Now, requests to the load balancer will be distributed among the running
+services:
+
+```bash
+curl localhost:8080/api
+# Output: api-service response from <port>
+```
+
+Run the curl command multiple times to see responses from different servers,
+confirming load balancing is working.

12-scalability-and-architectural-patterns/06-http-dynamic-load-balancer/app.js

@@ -0,0 +1,59 @@
+import { randomUUID } from 'node:crypto'
+import { createServer } from 'node:http'
+import portfinder from 'portfinder' // v1.0.37
+import { ConsulClient } from './consul.js'
+
+const serviceType = process.argv[2]
+if (!serviceType) {
+  console.error('Usage: node app.js <service-type>')
+  process.exit(1)
+}
+
+const consulClient = new ConsulClient()
+
+const port = await portfinder.getPort()
+const address = process.env.ADDRESS || 'localhost'
+const serviceId = randomUUID()
+
+async function registerService() {
+  await consulClient.registerService({
+    id: serviceId,
+    name: serviceType,
+    address,
+    port,
+    tags: [serviceType],
+  })
+
+  console.log(
+    `${serviceType} registered successfully as ${serviceId} on ${address}:${port}`
+  )
+}
+
+async function unregisterService(err) {
+  err && console.error(err)
+  console.log(`deregistering ${serviceId}`)
+  try {
+    await consulClient.deregisterService(serviceId)
+  } catch (deregisterError) {
+    console.error(`Failed to deregister service: ${deregisterError.message}`)
+  }
+  process.exit(err ? 1 : 0)
+}
+
+process.on('uncaughtException', unregisterService)
+process.on('SIGINT', unregisterService)
+
+const server = createServer((_req, res) => {
+  // Simulate some processing time
+  let i = 1e7
+  while (i > 0) {
+    i--
+  }
+  console.log(`Handling request from ${process.pid}`)
+  res.end(`${serviceType} response from ${process.pid}\n`)
+})
+
+server.listen(port, address, async () => {
+  console.log(`Started ${serviceType} on port ${port} with PID ${process.pid}`)
+  await registerService()
+})

12-scalability-and-architectural-patterns/06-http-dynamic-load-balancer/consul.js

@@ -0,0 +1,60 @@
+export class ConsulClient {
+  constructor(baseUrl = 'http://localhost:8500') {
+    this.baseUrl = baseUrl
+  }
+
+  async registerService({ name, id, address, port, tags = [] }) {
+    const url = `${this.baseUrl}/v1/agent/service/register`
+    const body = {
+      // biome-ignore lint/style/useNamingConvention: Consul API
+      Name: name,
+      // biome-ignore lint/style/useNamingConvention: Consul API
+      ID: id,
+      // biome-ignore lint/style/useNamingConvention: Consul API
+      Address: address,
+      // biome-ignore lint/style/useNamingConvention: Consul API
+      Port: port,
+      // biome-ignore lint/style/useNamingConvention: Consul API
+      Tags: tags,
+    }
+
+    const response = await fetch(url, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    })
+
+    if (!response.ok) {
+      const responseText = await response.text() // Read the response body to get more details
+      throw new Error(
+        `Failed to register service: ${response.statusText}\n${responseText}`
+      )
+    }
+  }
+
+  async deregisterService(serviceId) {
+    const url = `${this.baseUrl}/v1/agent/service/deregister/${serviceId}`
+    const response = await fetch(url, { method: 'PUT' })
+
+    if (!response.ok) {
+      const responseText = await response.text()
+      throw new Error(
+        `Failed to deregister service: ${response.statusText}\n${responseText}`
+      )
+    }
+  }
+
+  async getAllServices() {
+    const url = `${this.baseUrl}/v1/agent/services`
+    const response = await fetch(url)
+
+    if (!response.ok) {
+      const responseText = await response.text()
+      throw new Error(
+        `Failed to get all services: ${response.statusText}\n${responseText}`
+      )
+    }
+
+    return response.json()
+  }
+}

12-scalability-and-architectural-patterns/06-http-dynamic-load-balancer/loadBalancer.js

@@ -0,0 +1,48 @@
+import { createServer } from 'node:http'
+import { createProxyServer } from 'httpxy' // v0.1.7
+import { ConsulClient } from './consul.js'
+
+const routing = [
+  {
+    path: '/api',
+    service: 'api-service',
+    index: 0,
+  },
+  {
+    path: '/',
+    service: 'webapp-service',
+    index: 0,
+  },
+]
+
+const consulClient = new ConsulClient()
+const proxy = createProxyServer()
+
+const server = createServer(async (req, res) => {
+  const route = routing.find(route => req.url.startsWith(route.path))
+
+  try {
+    const services = await consulClient.getAllServices()
+    const servers = Object.values(services).filter(service =>
+      service.Tags.includes(route.service)
+    )
+
+    if (servers.length > 0) {
+      route.index = (route.index + 1) % servers.length
+      const server = servers[route.index]
+      const target = `http://${server.Address}:${server.Port}`
+      proxy.web(req, res, { target })
+      return
+    }
+  } catch (err) {
+    console.error(err)
+  }
+
+  // if servers not found or error occurs
+  res.writeHead(502)
+  return res.end('Bad gateway')
+})
+
+server.listen(8080, () => {
+  console.log('Load balancer started on port 8080')
+})

12-scalability-and-architectural-patterns/06-http-dynamic-load-balancer/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "06-http-dynamic-load-balancer",
+  "version": "1.0.0",
+  "description": "This example demonstrates how to implement a dynamic load balancer in Node.js using consul as a service discovery mechanism",
+  "type": "module",
+  "scripts": {},
+  "engines": {
+    "node": ">=24"
+  },
+  "engineStrict": true,
+  "keywords": [],
+  "author": "Luciano Mammino and Mario Casciaro",
+  "license": "MIT",
+  "devDependencies": {
+    "autocannon": "^8.0.0"
+  },
+  "dependencies": {
+    "httpxy": "^0.1.7",
+    "portfinder": "^1.0.37"
+  }
+}