आधुनिक सॉफ्टवेयर विकास में लोड बैलेंसर महत्वपूर्ण हैं। यदि आपने कभी सोचा है कि अनुरोध कई सर्वरों पर कैसे वितरित किए जाते हैं, या क्यों कुछ वेबसाइटें भारी ट्रैफ़िक के दौरान भी तेज़ महसूस करती हैं, तो इसका उत्तर अक्सर कुशल लोड संतुलन में निहित होता है।

इस पोस्ट में, हम गो में राउंड रॉबिन एल्गोरिदम का उपयोग करके एक सरल एप्लिकेशन लोड बैलेंसर बनाएंगे। इस पोस्ट का उद्देश्य यह समझना है कि एक लोड बैलेंसर चरण दर चरण हुड के नीचे कैसे काम करता है।

लोड बैलेंसर क्या है?

लोड बैलेंसर एक ऐसी प्रणाली है जो आने वाले नेटवर्क ट्रैफ़िक को कई सर्वरों में वितरित करती है। यह सुनिश्चित करता है कि कोई भी सर्वर बहुत अधिक भार न उठाए, बाधाओं को रोके और समग्र उपयोगकर्ता अनुभव में सुधार करे। लोड संतुलन दृष्टिकोण यह भी सुनिश्चित करता है कि यदि एक सर्वर विफल हो जाता है, तो ट्रैफ़िक को स्वचालित रूप से दूसरे उपलब्ध सर्वर पर पुनः रूट किया जा सकता है, जिससे विफलता का प्रभाव कम हो जाता है और उपलब्धता बढ़ जाती है।

हम लोड बैलेंसर्स का उपयोग क्यों करते हैं?

• उच्च उपलब्धता: ट्रैफ़िक वितरित करके, लोड बैलेंसर यह सुनिश्चित करते हैं कि भले ही एक सर्वर विफल हो, ट्रैफ़िक को अन्य स्वस्थ सर्वरों पर भेजा जा सकता है, जिससे एप्लिकेशन अधिक लचीला हो जाता है।
• स्केलेबिलिटी: लोड बैलेंसर्स आपको ट्रैफ़िक बढ़ने पर अधिक सर्वर जोड़कर अपने सिस्टम को क्षैतिज रूप से स्केल करने की अनुमति देते हैं।
• दक्षता: यह सुनिश्चित करके संसाधन उपयोग को अधिकतम करता है कि सभी सर्वर कार्यभार को समान रूप से साझा करते हैं।

लोड संतुलन एल्गोरिदम

ट्रैफ़िक को वितरित करने के लिए अलग-अलग एल्गोरिदम और रणनीतियाँ हैं:

• राउंड रॉबिन: उपलब्ध सबसे सरल तरीकों में से एक। यह उपलब्ध सर्वरों के बीच अनुरोधों को क्रमिक रूप से वितरित करता है। एक बार जब यह अंतिम सर्वर पर पहुंच जाता है, तो यह शुरुआत से फिर से शुरू हो जाता है।
• वेटेड राउंड रॉबिन: राउंड रॉबिन एल्गोरिदम के समान, सिवाय इसके कि प्रत्येक सर्वर को कुछ निश्चित संख्यात्मक भार सौंपा गया है। इस दिए गए वजन का उपयोग रूटिंग ट्रैफ़िक के लिए सर्वर को निर्धारित करने के लिए किया जाता है।
• न्यूनतम कनेक्शन: ट्रैफ़िक को सबसे कम सक्रिय कनेक्शन वाले सर्वर पर रूट करता है।
• आईपी हैशिंग: क्लाइंट के आईपी पते के आधार पर सर्वर का चयन करें।

इस पोस्ट में, हम एक राउंड रॉबिन लोड बैलेंसर को लागू करने पर ध्यान केंद्रित करेंगे।

राउंड रॉबिन एल्गोरिथम क्या है?

एक राउंड रॉबिन एल्गोरिदम प्रत्येक आने वाले अनुरोध को अगले उपलब्ध सर्वर पर गोलाकार तरीके से भेजता है। यदि सर्वर ए पहले अनुरोध को संभालता है, तो सर्वर बी दूसरे को संभालेगा, और सर्वर सी तीसरे को संभालेगा। एक बार जब सभी सर्वरों को अनुरोध प्राप्त हो जाता है, तो यह सर्वर ए से फिर से शुरू होता है।

अब, आइए कोड में जाएं और अपना लोड बैलेंसर बनाएं!

चरण 1: लोड बैलेंसर और सर्वर को परिभाषित करें

type LoadBalancer struct {
    Current int
    Mutex   sync.Mutex
}

हम पहले एक करंट फ़ील्ड के साथ एक सरल लोडबैलेंसर संरचना को परिभाषित करेंगे ताकि यह पता चल सके कि किस सर्वर को अगले अनुरोध को संभालना चाहिए। म्यूटेक्स यह सुनिश्चित करता है कि हमारा कोड एक साथ उपयोग करने के लिए सुरक्षित है।

हम जिस भी सर्वर पर बैलेंस लोड करते हैं, उसे सर्वर संरचना द्वारा परिभाषित किया जाता है:

type Server struct {
    URL       *url.URL
    IsHealthy bool
    Mutex     sync.Mutex
}

यहां, प्रत्येक सर्वर में एक यूआरएल और एक IsHealthy ध्वज होता है, जो इंगित करता है कि सर्वर अनुरोधों को संभालने के लिए उपलब्ध है या नहीं।

चरण 2: राउंड रॉबिन एल्गोरिथम

हमारे लोड बैलेंसर का दिल राउंड रॉबिन एल्गोरिदम है। यह ऐसे काम करता है:

func (lb *LoadBalancer) getNextServer(servers []*Server) *Server {
    lb.Mutex.Lock()
    defer lb.Mutex.Unlock()

    for i := 0; i 

• यह विधि सर्वर की सूची को राउंड रॉबिन फैशन में लूप करती है। यदि चयनित सर्वर स्वस्थ है, तो यह आने वाले अनुरोध को संभालने के लिए उस सर्वर को वापस कर देता है।
• हम यह सुनिश्चित करने के लिए म्यूटेक्स का उपयोग कर रहे हैं कि एक समय में केवल एक गोरोइन लोड बैलेंसर के वर्तमान क्षेत्र तक पहुंच और संशोधित कर सकता है। यह सुनिश्चित करता है कि जब कई अनुरोधों को एक साथ संसाधित किया जा रहा हो तो राउंड रॉबिन एल्गोरिदम सही ढंग से काम करता है।
• प्रत्येक सर्वर का अपना म्यूटेक्स भी होता है। जब हम IsHealthy फ़ील्ड की जांच करते हैं, तो हम एकाधिक गोरआउट्स से समवर्ती पहुंच को रोकने के लिए सर्वर के म्यूटेक्स को लॉक कर देते हैं।
• म्यूटेक्स लॉकिंग के बिना यह संभव है कि कोई अन्य गोरोइन मूल्य बदल सकता है जिसके परिणामस्वरूप गलत या असंगत डेटा पढ़ा जा सकता है।
• जैसे ही हमने वर्तमान फ़ील्ड को अपडेट किया है या महत्वपूर्ण अनुभाग को यथासंभव छोटा रखने के लिए IsHealthy फ़ील्ड मान को पढ़ा है, हम म्यूटेक्स को अनलॉक कर देते हैं। इस तरह, हम किसी भी दौड़ की स्थिति से बचने के लिए म्यूटेक्स का उपयोग कर रहे हैं।

चरण 3: लोड बैलेंसर को कॉन्फ़िगर करना

हमारा कॉन्फ़िगरेशन एक config.json फ़ाइल में संग्रहीत है, जिसमें सर्वर यूआरएल और स्वास्थ्य जांच अंतराल शामिल हैं (नीचे अनुभाग में इसके बारे में अधिक जानकारी)।

type Config struct {
    Port                string   `json:"port"`
    HealthCheckInterval string   `json:"healthCheckInterval"`
    Servers             []string `json:"servers"`
}

कॉन्फ़िगरेशन फ़ाइल इस तरह दिख सकती है:

{
  "port": ":8080",
  "healthCheckInterval": "2s",
  "servers": [
    "http://localhost:5001",
    "http://localhost:5002",
    "http://localhost:5003",
    "http://localhost:5004",
    "http://localhost:5005"
  ]
}

चरण 4: स्वास्थ्य जांच

हम किसी भी आने वाले ट्रैफ़िक को रूट करने से पहले यह सुनिश्चित करना चाहते हैं कि सर्वर स्वस्थ हैं। यह प्रत्येक सर्वर पर समय-समय पर स्वास्थ्य जांच भेजकर किया जाता है:

func healthCheck(s *Server, healthCheckInterval time.Duration) {
    for range time.Tick(healthCheckInterval) {
        res, err := http.Head(s.URL.String())
        s.Mutex.Lock()
        if err != nil || res.StatusCode != http.StatusOK {
            fmt.Printf("%s is down\n", s.URL)
            s.IsHealthy = false
        } else {
            s.IsHealthy = true
        }
        s.Mutex.Unlock()
    }
}

प्रत्येक कुछ सेकंड में (जैसा कि कॉन्फ़िगरेशन में निर्दिष्ट है), लोड बैलेंसर यह जांचने के लिए प्रत्येक सर्वर को एक HEAD अनुरोध भेजता है कि क्या यह स्वस्थ है। यदि कोई सर्वर डाउन है, तो IsHealthy फ़्लैग गलत पर सेट हो जाता है, जिससे भविष्य में ट्रैफ़िक को उस पर रूट होने से रोका जा सकता है।

चरण 5: प्रॉक्सी को उल्टा करें

जब लोड बैलेंसर को एक अनुरोध प्राप्त होता है, तो यह रिवर्स प्रॉक्सी का उपयोग करके अनुरोध को अगले उपलब्ध सर्वर पर भेज देता है। गोलांग में, httputil पैकेज रिवर्स प्रॉक्सीइंग को संभालने के लिए एक अंतर्निहित तरीका प्रदान करता है, और हम इसे रिवर्सप्रॉक्सी फ़ंक्शन के माध्यम से अपने कोड में उपयोग करेंगे:

func (s *Server) ReverseProxy() *httputil.ReverseProxy {
    return httputil.NewSingleHostReverseProxy(s.URL)
}

रिवर्स प्रॉक्सी क्या है?

रिवर्स प्रॉक्सी एक सर्वर है जो क्लाइंट और एक या अधिक बैकएंड सेवर्स के बीच बैठता है। यह क्लाइंट का अनुरोध प्राप्त करता है, इसे बैकएंड सर्वरों में से एक को अग्रेषित करता है, और फिर क्लाइंट को सर्वर की प्रतिक्रिया लौटाता है। क्लाइंट प्रॉक्सी के साथ इंटरैक्ट करता है, इस बात से अनजान कि कौन सा विशिष्ट बैकएंड सर्वर अनुरोध को संभाल रहा है।

हमारे मामले में, लोड बैलेंसर एक रिवर्स प्रॉक्सी के रूप में कार्य करता है, जो कई सर्वरों के सामने बैठता है और आने वाले HTTP अनुरोधों को वितरित करता है।

चरण 6: अनुरोधों को संभालना

जब कोई क्लाइंट लोड बैलेंसर से अनुरोध करता है, तो वह getNextServer फ़ंक्शन में राउंड रॉबिन एल्गोरिदम कार्यान्वयन का उपयोग करके अगले उपलब्ध स्वस्थ सर्वर का चयन करता है और क्लाइंट अनुरोध को उस सर्वर पर प्रॉक्सी करता है। यदि कोई स्वस्थ सर्वर उपलब्ध नहीं है तो हम क्लाइंट को सेवा अनुपलब्ध त्रुटि भेजते हैं।

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        server := lb.getNextServer(servers)
        if server == nil {
            http.Error(w, "No healthy server available", http.StatusServiceUnavailable)
            return
        }
        w.Header().Add("X-Forwarded-Server", server.URL.String())
        server.ReverseProxy().ServeHTTP(w, r)
    })

रिवर्सप्रॉक्सी विधि अनुरोध को वास्तविक सर्वर पर प्रॉक्सी करती है, और हम डिबगिंग उद्देश्यों के लिए एक कस्टम हेडर एक्स-फॉरवर्डेड-सर्वर भी जोड़ते हैं (हालांकि उत्पादन में, हमें इस तरह आंतरिक सर्वर विवरण को उजागर करने से बचना चाहिए)।

चरण 7: लोड बैलेंसर शुरू करना

अंत में, हम निर्दिष्ट पोर्ट पर लोड बैलेंसर शुरू करते हैं:

log.Println("Starting load balancer on port", config.Port)
err = http.ListenAndServe(config.Port, nil)
if err != nil {
        log.Fatalf("Error starting load balancer: %s\n", err.Error())
}

कार्यशील डेमो

टीएल;डीआर

इस पोस्ट में, हमने राउंड रॉबिन एल्गोरिदम का उपयोग करके गोलांग में स्क्रैच से एक बुनियादी लोड बैलेंसर बनाया है। यह कई सर्वरों पर ट्रैफ़िक वितरित करने और यह सुनिश्चित करने का एक सरल लेकिन प्रभावी तरीका है कि आपका सिस्टम उच्च लोड को कुशलतापूर्वक संभाल सकता है।

अन्वेषण करने के लिए और भी बहुत कुछ है, जैसे परिष्कृत स्वास्थ्य जांच जोड़ना, विभिन्न लोड संतुलन एल्गोरिदम लागू करना, या दोष सहनशीलता में सुधार करना। लेकिन यह बुनियादी उदाहरण निर्माण के लिए एक ठोस आधार हो सकता है।

आप इस GitHub रेपो में स्रोत कोड पा सकते हैं।