इन दिनों, हमारे एप्लिकेशन के लिए दूसरों पर निर्भर रहना काफी आम है, खासकर यदि हम माइक्रोसर्विसेज वातावरण में काम कर रहे हैं। हमारे एप्लिकेशन के लिए त्रुटियों की रिपोर्ट करना शुरू करना काफी सामान्य है, और जांच करते समय, हम देखते हैं कि किसी भागीदार टीम या आपूर्तिकर्ता से कुछ एपीआई नीचे है।

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

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

अंत में, राज्य हैं:

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

बहुत बढ़िया, है ना? लेकिन अवधारणा को बेहतर ढंग से उदाहरण देने के लिए, हम इसे व्यवहार में कैसे लाएँ?

सबसे पहले, आइए अपनी सेवा ए बनाएं। यह अनुरोध प्राप्त करने के लिए ज़िम्मेदार होगी, यानी, यह वह सेवा होगी जिस पर हमारा एप्लिकेशन निर्भर करता है, आपूर्तिकर्ता की सेवा, या आदि। इसे आसान बनाने के लिए, हम दो अंतिम बिंदुओं को उजागर करेंगे, एक /सफलता जो हमेशा 200 लौटाएगी और एक /असफलता जो हमेशा 500 लौटाएगी।

package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/success", func(w http.ResponseWriter, r *http.Request) { 
    w.WriteHeader(http.StatusOK) })
    http.HandleFunc("/failure", func(w http.ResponseWriter, r *http.Request) { 
    w.WriteHeader(http.StatusInternalServerError) })

    fmt.Println("Server is running at http://localhost:8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

सेवा बी सेवा ए को कॉल करने के लिए जिम्मेदार होगी। यह हमारे सर्किट ब्रेकर का निर्माण करेगी। हमारे लिए सौभाग्य की बात है कि गो समुदाय के पास पहले से ही गोब्रेकर लाइब्रेरी है जो पैटर्न को लागू करती है! सबसे पहले, हम अपने ब्रेकर के गुणों को परिभाषित करते हैं:

var st gobreaker.Settings
st.Name = "Circuit Breaker PoC"
st.Timeout = time.Second * 5
st.MaxRequests = 2
st.ReadyToTrip = func(counts gobreaker.Counts) bool {
    return counts.ConsecutiveFailures >= 1
}

हालांकि लाइब्रेरी हमें और अधिक चीजों को अनुकूलित करने की अनुमति देती है, हम तीन पर ध्यान केंद्रित करेंगे:

• टाइमआउट: वह समय जब सर्किट खुली अवस्था में रहेगा। हमारे मामले में, समय 5 सेकंड निर्धारित किया गया था।
• MaxRequests: बंद होने से पहले सफल अनुरोधों की संख्या। हमारे उदाहरण में, हम इसे 2 अनुरोधों के रूप में परिभाषित करते हैं।
• ReadyToTrip: बंद से खुले में संक्रमण की स्थिति को परिभाषित करता है। चीजों को आसान बनाने के लिए, मान लीजिए कि एक विफलता ही काफी है।

तब हम ब्रेकर को आरंभ कर सकते हैं और अनुरोध कर सकते हैं:

cb := gobreaker.NewCircuitBreaker[int](st)

url := "http://localhost:8080/success"
cb.Execute(func() (int, error) { return Get(url) })
fmt.Println("Circuit Breaker state:", cb.State()) // closed!

url = "http://localhost:8080/failure"
cb.Execute(func() (int, error) { return Get(url) })
fmt.Println("Circuit Breaker state:", cb.State()) // open!

time.Sleep(time.Second * 6)
url = "http://localhost:8080/success"
cb.Execute(func() (int, error) { return Get(url) })
fmt.Println("Circuit Breaker state:", cb.State()) // half-open!

url = "http://localhost:8080/success"
cb.Execute(func() (int, error) { return Get(url) })
fmt.Println("Circuit Breaker state:", cb.State()) // closed!

हम देख सकते हैं कि गोब्रेकर एक फ़ंक्शन के चारों ओर एक आवरण के रूप में काम करता है। यदि फ़ंक्शन कोई त्रुटि देता है, तो यह त्रुटियों की संख्या बढ़ाता है, यदि नहीं, तो यह सफलताओं की संख्या बढ़ाता है। तो आइए इस फ़ंक्शन को परिभाषित करें:

func Get(url string) (int, error) {
    r, _ := http.Get(url)

    if r.StatusCode != http.StatusOK {
        return r.StatusCode, fmt.Errorf("failed to get %s", url)
    }

    return r.StatusCode, nil
}

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

यदि आप अन्य लचीलेपन पैटर्न जानने के लिए उत्सुक हैं, तो एल्टन मिनेटो ने इस विषय पर एक बेहतरीन पोस्ट प्रकाशित की है!

मुझे टिप्पणियों में बताएं कि आप इस पोस्ट के बारे में क्या सोचते हैं और यहां एक प्रश्न है: क्या आपने पहले कभी सर्किट ब्रेकर का उपयोग किया है? ओह, आप मुझे मेरे निजी ब्लॉग पर भी पा सकते हैं!