🔥 ⚔️ Build Dynamic Load Balancer

შესავალი

გამარჯობა, ეს არის ჩემი პირველი სტატია ქართულ ენაზე და როგორც სათაურიდან ჩანს, ამ სტატიაში მინდა ვისაუბრო dynamic load balancer-ზე და შემდეგ ერთად დავწეროთ nodejs-ის გამოყენებით.

Dynamic horizontal Scaling

ერთ-ერთი მნიშვნელოვანი უპირატესობა, რაც ქლაუდზე დაფუძნებულ ინფრასტრუქტურას აქვს არის ის რომ, მათ შეუძლიათ დინამიურად გამოუყონ რამხელა რესურსიც სჭრიდება აპლიკაციიას, იმის მიხედვით თუ რა ტრეფიკი მოდის მასზე. Dynamic scaling-ითაც არის ცნობილი ეს საკითხი. თუ სწორად დავაიმპლემენტირებთ, ამ მიდგომამ შესაძლოა საგრძნობლად შეამციროს IT ინფრასტრუქტურის ფასი, ისე რომ აპლიკაცია ისევ highly available - მაღალ ხელმისწავდომი დარჩეს.

Idea

იდეა არის მარტივი: თუ აპლიკაციას აქვს პერფორმანსის ვარდნა მაღალი ტრეფიკის გამო, სისტემა ავტომატურად ამრავლებს მის ინსტანსტებს ახალ სერვერზე, რომ გაუმკლავდეს დატვირთვას. ანალოგიურად, თუ გამოყოფილი რესურსები ვერ გამოიყენება, ზედმეტია, მაშინ უნდა გამოვრთოთ ზოგიერთი მათგანი, რომ შევამციროთ ხარჯი.

ეს სკალირება შეიძლება გვქონდეს დაშედულებული, რაც იმას ნიშნავს, რომ რაღაც საათებში შეიძლება გამოვრთოთ რომელიღაც სერვისები, რადგან ვიცით რომ ამ პერიოდში დატვირთვა ძალიან იკლებს და დავარესტარტოთ როგორც კი დაიწყება ის საათები, როცა დაწოლა მაღალია.

Service Registry

ზოგადი პატერნი, რომ ეს პრობლემა გადავჭრათ არის, რომ გამოვიყენოთ ცენტრალური რეპოზიტორი - service registry, რომელიც შეინახავს და დატრეკავს, რომელი სერვერია გაშვებული და რომელი სერვისები ამ სერვერზე.

როგორც დიაგრამიდან ჩანს, როცა რექვექსტი მივა example.com-ზე, ლოად ბალანსერი ამოწმებს რექვესტის პრეფიქსს, თუ იწყება /api-ით ესიგი რექვესტი უნდა დაბალანსდეს API service ინსტანსებზე, როგორც ვხედავთ სულ API-სთვის გვაქვს ორი ინსტანსი, ორგან გვაქვს გაშვებული ეს პროცესი, api1-ზე და api2-ზე.

Implementing a dynamic load balancer with http-proxy and Consul

სერვის რეგისტრატორად ვიყენებ Consul-ს, აქ მეტს აღარ შევალ დეტალებში, შეგიძლიათ ნახოთ დოკუმენტაცია. კონსულის გამოყენების მთავარი აზრია, რომ გავიმეოროთ ის მულტისერვისული არქიტექტურა, რომელიც ზემოთ აღწერილ დიაგრამაზეა. სულ გამოვიყენებ 3 ბიბლიოთეკას:

ბიბლიოთეკები, რომლებსაც გამოვიყენებ

http-proxy - გავამარტივოთ reverse-proxy/load-balancer-ის შექმნა ნოუდზე

portfinder: ამას ახსნა არ უნდა,სახელი გვეუბნება

consul: ინტერაქცია რომ გვქონდეს Consul-თან

მოდი გადავიდეთ იმპლემენტაციის ნაწილზე უშუალოდ.

Setting up the Service For Registration

დავწეროთ სერვის რეგისტრატორი, ამ შემთხვევაში სერვისის სახელს მივიღებთ command-line-დან. მოდი დავიწყოთ და თან ავხსნათ.

app.js

import { createServer } from 'http';
import Consul from 'consul';
import portfinder from 'portfinder';
import { nanoid } from 'nanoid';
 
 
// დავიჭიროთ სერვისის ტიპი, რომელსაც ვარეგისტრირებთ
const serviceType = process.argv[2];
 
const { pid } = process;

ახლა გვინდა, რომ დავარეგისტრიროთ სერვისი, რომლის ტიპი ვიცით(სახელიც შეგვიძლია ვთქვათ), გვჭირდება უკვე ინიციალიზაცია გავუკეთოთ კონსულს,გავატანოთ უნიკალური id, სახელი ამ სერვისის, მოვძებნოთ თავისუფალი პორტი რომელზეც გვინდა ჩვენი ინსტანსი გაეშვას, და ტეგები, რომელიც არ არის აუცილებელი მოთხოვნა,მაგრამ ჩვენ ტეგებში მოვძებნით შემდგომში უკვე საჭირო სერვისის ინსტანსს. ძირითადად ტეგების გამოყენების მიზანია კატეგორიზაცია გარკვეული სერვისების, გაფილტვრა შემდგომ მარტივად და დამატებითი ინფორმაციის გატანა, რა გარემოშია გაშვებული ეს სერვისი და ა.შ. აღარ ჩავალ სიღრმეებში. ესეიგი ჩვენს გასაშვებ ინსტანსს მოვუძებნეთ პორტი, ხოლო კონსულს გავაატნეთ მისი, როგორც სერვისის სახელი, id, address, port,tags. მოდი გავაგრძელოთ...

app.js

import { createServer } from 'http';
import Consul from 'consul';
import portfinder from 'portfinder';
import { nanoid } from 'nanoid';
 
// დავიჭიროთ სერვისის ტიპი, რომელსაც ვარეგისტრირებთ
const serviceType = process.argv[2];
 
const { pid } = process;
 
async function main() {
	const consulClient = new Consul();
 
	// ① Discover a free port in the system and generate a unique service ID
	const port = await portfinder.getPortPromise();
	const address = process.env.ADDRESS || "localhost";
	const serviceId = nanoid();
	function registerService() {
		consulClient.agent.service.register(
			{
				id: serviceId,
				name: serviceType,
				address,
				port,
				tags: [serviceType],
			},
			() => {
				console.log(`${serviceType} registered successfully`);
			}
		);
	}

ეხლა დავწეროთ ამ სერვისი ამოღება/წაშლა კონსულის რეგისტრიდან.მთავარი მიზანი ამ ფუნცქიის გამოყენების იქნება ის,რომ თუ საჭირო გახდა სერვისი გამორთვა ან თუ ერორი მოხდა,ან რაიმე ექსეფშენი გაისროლა ჩვენი სერვისის პროცესმა, უნდა წაიშალოს ეს სერვისი კონსულიდან სანამ თავად პროცესი მოკვდება.

app.js

import { createServer } from 'http';
import Consul from 'consul';
import portfinder from 'portfinder';
import { nanoid } from 'nanoid';
 
// დავიჭიროთ სერვისის ტიპი, რომელსაც ვარეგისტრირებთ
const serviceType = process.argv[2];
 
const { pid } = process;
 
async function main() {
	const consulClient = new Consul();
 
	// ① Discover a free port in the system and generate a unique service ID
	const port = await portfinder.getPortPromise();
	const address = process.env.ADDRESS || "localhost";
	const serviceId = nanoid();
	function registerService() {
		consulClient.agent.service.register(
			{
				id: serviceId,
				name: serviceType,
				address,
				port,
				tags: [serviceType],
			},
			() => {
				console.log(`${serviceType} registered successfully`);
			}
		);
	}
 
	function unregisterService(err) {
		err && console.error(err);
		onsole.log(`deregistering ${serviceId}`);
		consulClient.agent.service.deregister(serviceId, () => {
			process.exit(err ? 1 : 0);
		});
	}
 
 
	// დავარეგისტრიროთ
	process.on("exit", unregisterService);
	process.on("uncaughtException", unregisterService);
	process.on("SIGINT", unregisterService);

ახლა კი ბოლო ეტაპი, შევქმნათ HTTP სერვერი, ნოუდის http მოდულის გამოყენებით, დავსვათ ჩვენს პორტზე და მისამართზე, და სიმულაცია გავაკეთოთ თითქოს რექვესტები შემოდის ამ მისამართზე.

app.js

import { createServer } from 'http';
import Consul from 'consul';
import portfinder from 'portfinder';
import { nanoid } from 'nanoid';
 
// დავიჭიროთ სერვისის ტიპი, რომელსაც ვარეგისტრირებთ
const serviceType = process.argv[2];
 
const { pid } = process;
 
async function main() {
	const consulClient = new Consul();
 
	// ① Discover a free port in the system and generate a unique service ID
	const port = await portfinder.getPortPromise();
	const address = process.env.ADDRESS || "localhost";
	const serviceId = nanoid();
	function registerService() {
		consulClient.agent.service.register(
			{
				id: serviceId,
				name: serviceType,
				address,
				port,
				tags: [serviceType],
			},
			() => {
				console.log(`${serviceType} registered successfully`);
			}
		);
	}
 
	function unregisterService(err) {
		err && console.error(err);
		onsole.log(`deregistering ${serviceId}`);
		consulClient.agent.service.deregister(serviceId, () => {
			process.exit(err ? 1 : 0);
		});
	}
 
 
	// დავარეგისტრიროთ დერეგისტრირეების ფუნქცია
	process.on("exit", unregisterService);
	process.on("uncaughtException", unregisterService);
	process.on("SIGINT", unregisterService);
 
 
	const server = createServer((req, res) => {
		let i = 1e7;
		while (i > 0) {
		  i--;
		}
		console.log(`Handling request from ${pid}`);
		res.end(`${serviceType} response from ${pid}\n`);
	});
 
	server.listen(port, address, () => {
		registerService();
		console.log(`Started ${serviceType} at ${pid} on port ${port}`);
	});

ეს იყო ჩვენი ინსტანსის როგორც სერვისის რეგისტრაციაა და მისი დაჯენა გამოყოფილ უნიკალურ პორტსა და მისამართზე.

ახლა, გადავიდეთ მეორე ნაწილზე. დავწეროთ ლოად-ბალანსერი, რომელიც შემომავალ რექვესტებს გადაანაწილებს სხვადასხხვა სერვისებზე,იმის მიხედვით თუ რა იქნება როუტის პრეფიქსი.

Setting up the Load-Balancer

პირველ რიგში, დავარეგისტრიროთ როუტები, ანუ რომელ მისამართზე, რომელ სერვის უნდა მიმართოს ლოად ბალანსერმა.

load-balancer.js

import { createServer } from 'http';
import httpProxy from 'http-proxy';
import Consul from 'consul';
 
 
// ① განვსაზვროთ როუტები ლოად ბალანსერისთვის
const routing = [
	{
	  path: "/api", //რექვესტი რომელის დაიწყება /api მისამართით, გადამისამართდება api-service-ზე
	  service: "api-service",
	  index: 0,
	},
	{
	  path: "/", // ამ მისამართით დაწყებული რექვესტი კი გადამისამართდება webapp-service-ზე.
	  service: "webapp-service",
	  index: 0,
	},
];

ახლა უკვე შეგვიძლია, კონსულის კლიენტის ინიციალიზია, რომ მივწდეთ ჩვენთვის სასურველ სერვის და httpProxy ბიბლიოთეკის გამოყენებით, გადავამისამართოთ შემომავალი რექვესტი შესაბამის ინსტანზე, რომელსაც დააბრუნებს ჩვენი Consule-ის კლიენტი, შემომავალი რექვესტის როუტის პრეფიქსის მიხედვით,რაც ზემოთ უკვე ვახსენეთ.

load-balancer.js

import { createServer } from 'http';
import httpProxy from 'http-proxy';
import Consul from 'consul';
 
// ① განვსაზვროთ როუტები ლოად ბალანსერისთვის
const routing = [
  {
    path: '/api', //რექვესტი რომელის დაიწყება /api მისამართით, გადამისამართდება api-service-ზე
    service: 'api-service',
    index: 0,
  },
  {
    path: '/', // ამ მისამართით დაწყებული რექვესტი კი გადამისამართდება webapp-service-ზე.
    service: 'webapp-service',
    index: 0,
  },
];
 
const consulClient = new Consul();
 
const proxy = httpProxy.createProxyServer();
const server = createServer(async (req, res) => {
	//1️⃣
	const route = routing.find((route) => req.url.startsWith(route.path));
 
	try {
		//2️⃣
		const serviseList = await consulClient.agent.service.list();
		const instances = Object.values(serviseList).filter((service) =>
			service.Tags.includes(route.service)
		);
		if (!instances.length) {
			res.writeHead(502);
			return res.end("Bad gateway");
		}
 
		//3️⃣
		route.index = (route.index + 1) % instances.length;
		const instance = instances[route.index];
		const target = `http://${instance.Address}:${instance.Port}`;
		proxy.web(req, res, { target });
	} catch (error) {
		// If there's an error or no servers are found, return a "Bad gateway" error
		console.error("Error fetching services", error);
		res.writeHead(502);
		return res.end("Bad gateway");
	}
});
 
 
// Start the load balancer on port 8080
server.listen(8080, () => console.log("Load balancer started on port 8080"));

ესეიგი რა დავამატეთ,

1️⃣ვნახეთ ის როუტი, რომელიც იწყება შემომავალი რექვსეტის ურლ-is path-ით.
2️⃣ წამოვიღოთ ყველა სერვისის ლისტი, და უშუალოდ იმ სერვისით გავფილტროთ რომელიც როუტის სერვისს ემთხვევა.ამ შემთხვევაში ვფილტრავ ტეგით, ისე შეგვიძლია ჩვენს შემთხვევაში name-ითაც გაგვეფილტრა. როგორც ვახსენე ზემოთ, ტეგები გამოიყენება რომ კატეგორიებად დავყოთ, ე.წ.ლეიბლები დავადოთ სერვისებს, და მათით გაფილტვრა უფრო მეტად მიზანშეწონილია. თუ ეგეთი სერვისის ინსტანსი/ინსტანსები არ არსებობს ვისვრით 502 ერორს,ანუ არასწორ როუტს მიმართავენ.
3️⃣ ახლა რაც შეეხება, თუ ვიპოვნეთ ინსტანსები ამ ტიპის სერვისის, როგორ ვანაწილებთ ამ შემთხვევაში დატვირთვას. მე ვიყენებ აქ რაუნდ-რობინის ალგორითმს. თუ მაქვს ერთი სერვისის 7 ინსტანსი, თითოეულ ჯერზე route.index = (route.index + 1)% 7), ასე ვაახლებ ინდექს, და ვმოძრაობთ წრეზე წრეზე: 1,2,3,4,5,6,0,1,2... შესაბამისად ტრეფიკის გადანაწილება მექნება თანაბარი.

ბოლოს კი ჩვენი ლოად ბალანსერი გავუშათ, 8080 პორტზე და ვუსმინოთ შემომავალ რექვესტებს.

მოდი გავტესტოთ რაღაცეები,დავსტარტოთ ჯერ ლოად-ბალანსერი:

forever start -f --killSignal=SIGINT src/load-balancer.js

ახლა,მოდი გავუშვათ პარალელურად 2 სერვისი api-service-სთვის და 1 სერვისი webapp-service-სთვის, ვიყენებთ forever ბიბლიოთეკას:

	forever start -f --killSignal=SIGINT src/app.js api-service    
	forever start -f --killSignal=SIGINT src/app.js api-service    
	forever start -f --killSignal=SIGINT src/app.js webapp-service

ლოად ბალანსერი ავტომატურად დაინახავს ახალ ინსტანსებს, რაც დაისტარტა და დაიწყებს რექვესტების გადანაწილებას.

ახლა, რომ გავუშვათ ორჯერ api-ზე რექევსტი, დავინახავთ რომ სხვადასხვა ინსტანსი დაიჭერს.

curl localhost:8080/api

მადლობა ყურადღებისთვის. სრული კოდის ლინკი