गोलांग पुनः प्रयास पुस्तकालय का उपयोग करके असफल पुनः प्रयास कार्यों का अंमल करना

अध्याय 1: गो में पुन: प्रयास का परिचय

1.1 पुन: प्रयास की आवश्यकता को समझना

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

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

1.2 go-retry पुस्तकालय का अवलोकन

गो में go-retry पुस्तकालय विभिन्न बैकऑफ स्ट्रैटेज़ के साथ आपके एप्लिकेशन में पुन: प्रयास तार्किक जोड़ने के लिए एक लचीला तरीका प्रदान करती है। मुख्य विशेषताएँ शामिल हैं:

• विस्तारयोग्यता: गो के http पैकेज की तरह, go-retry को मध्यवर्ती के साथ विस्तारयोग्य बनाया गया है। आप खुद भी अपनी बैकऑफ फ़ंक्शन्स लिख सकते हैं या प्रासंगिक फ़िल्टर्स का उपयोग कर सकते हैं।
• स्वतंत्रता: पुस्तकालय केवल गो मानक पुस्तकालय पर निर्भर होती है और बाह्य आधारणों से बचती है, जिससे आपका प्रोजेक्ट हल्का रहता है।
• संयुक्तता: यह संयुक्त उपयोग के लिए सुरक्षित है और किसी भी अतिरिक्त परेशानी के बिना गोरूटिनों के साथ काम कर सकती है।
• संदर्भ-जागरुकता: यह गो के साथी निवेश को समर्थन करती है जो समयसीमा और रद्दीकरण के लिए गो के एकीकृतता समर्थन करती है, गो के संयोजन मॉडल के साथ समर्थित करती है।

अध्याय 2: पुस्तकालयों का आयात

go-retry पुस्तकालय का उपयोग करने से पहले, इसे आपके प्रोजेक्ट में आयात किया जाना आवश्यक है। इसे go get का उपयोग करके किया जा सकता है जो आपके मॉड्यूल में विभिन्नताओं को जोड़ने के लिए गो कमांड है। सिर्फ अपने टर्मिनल को खोलें और निम्नलिखित को क्रियान्वित करें:

go get github.com/sethvargo/go-retry

यह कमाण्ड go-retry पुस्तकालय को प्राप्त करेगा और इसे आपके प्रोजेक्ट की आवश्यकताओं में जोड़ देगा। इसके बाद, आप इसे अपने कोड में किसी भी अन्य गो पैकेज की तरह आयात कर सकते हैं।

अध्याय 3: मूल पुन: प्रयास तार्किक कार्यान्वयन

3.1 स्थिर बैकऑफ के साथ सरल पुन: प्रयास

सबसे सरल प्रकार का पुन: प्रयास तार्किक कार्यान्वयन छोटे समय अंतर से प्रत्येक प्रयास के बीच ठहरे रहने का होता है। आप go-retry का उपयोग करके सरल बैकऑफ के साथ पुन: प्रयास कर सकते हैं।

go-retry के साथ स्थिर बैकऑफ का उपयोग कैसे करें, इसका निम्नलिखित उदाहरण दिया गया है:

package main

import (
  "context"
  "time"
  "github.com/sethvargo/go-retry"
)

func main() {
    ctx := context.Background()
    
    // एक नया स्थिर बैकऑफ बनाएँ
    backoff := retry.NewConstant(1 * time.Second)

    // अपनी पुन: प्रयास तार्किकता को एक फ़ंक्शन में लपेटें जिसे पुन: प्रयास के लिए धराया जाएगा
    operation := func(ctx context.Context) error {
        // आपका कोड यहां। यदि फ़ंक्शन क्या करता है
        // Example:
        // err := someOperation()
        // if err != nil {
        //   return retry.RetryableError(err)
        // }
        // return nil

        return nil
    }
    
    // इच्छित संदर्भ, बैकऑफ रणनीति और कार्रवाई के साथ पुनः प्रयास के लिए retry.Do का उपयोग करें
    if err := retry.Do(ctx, backoff, operation); err != nil {
        // त्रुटि का सम्हालन करें
    }
}

इस उदाहरण में, retry.Do फ़ंक्शन प्रति 1 सेकंड में operation फ़ंक्शन को प्रत्येक 1 सेकंड के लिए कोशिश करेगा, जब तक यह सफल नहीं होता या संदर्भ का समयावधि समाप्त नहीं हो जाता है या रद्द नहीं होता है।

3.2 गणनात्मक बैकऑफ का अमल

गणनात्मक बैकऑफ, पुन: प्रयास के बीच प्रत्येक बार ठहराव को गणनात्मक रूप से बढ़ाता है। यह रणनीति सिस्टम पर भार को कम करने में मदद करती है और विशेष रूप से विस्तृत पैमाने के सिस्टम या क्लाउड सेवाओं के साथ काम करते समय उपयोगी होती है।

go-retry के साथ गणनात्मक बैकऑफ का उपयोग कैसे करें, इसका निम्नलिखित उदाहरण दिया गया है:

package main

import (
  "context"
  "time"
  "github.com/sethvargo/go-retry"
)

func main() {
    ctx := context.Background()

    // एक नया गणनात्मक बैकऑफ बनाएँ
    backoff := retry.NewExponential(1 * time.Second)

    // अपने पुन: प्रयास योग्य कार्रवाई को प्रदान करें
    operation := func(ctx context.Context) error {
        // पूर्ववर्ती रूप से दिखाई गई ऑपरेशन का अमल करें
        return nil
    }
    
    // गणनात्मक बैकऑफ के साथ कार्रवाई का अमल करने के लिए retry.Do का उपयोग करें
    if err := retry.Do(ctx, backoff, operation); err != nil {
        // त्रुटि का सम्हालन करें
    }
}

गणनात्मक बैकऑफ के मामले में, यदि प्रारंभिक बैकऑफ को 1 सेकंड पर सेट किया गया है, तो पुन: प्रयास 1 सेकंड, 2 सेकंड, 4 सेकंड आदि के बाद होगा, और उत्तराधिकारक पुनरावृत्ति के बीच प्रतीक्षा की गई समय में वृद्धि करेगा।

3.3 फिबोनाची बैकऑफ़ रणनीति

फिबोनाची बैकऑफ़ रणनीति का उपयोग रिट्राय के बीच प्रतीक्षा का समय निर्धारित करने के लिए फिबोनाची श्रृंखला का उपयोग करती है, जो नेटवर्क संबंधित मुद्दों के लिए एक धीरे-धीरे बढ़ते समय के लाभकारी रणनीति हो सकती है।

go-retry के साथ फिबोनाची बैकऑफ़ को लागू करना नीचे दिखाया गया है:

package main

import (
  "context"
  "time"
  "github.com/sethvargo/go-retry"
)

func main() {
    ctx := context.Background()

    // नया फिबोनाची बैकऑफ़ बनाएँ
    backoff := retry.NewFibonacci(1 * time.Second)

    // रिट्राय करने के लिए कार्य को परिभाषित करें
    operation := func(ctx context.Context) error {
        // यहां वह तरीका होगा जिसे पुन:प्रायास करने की आवश्यकता है और जिसे पुन:प्रायास करने की आवश्यकता है
        return nil
    }
    
    // फिबोनाची बैकऑफ़ के साथ कार्य को निष्पादित करें और रिट्राय करें
    if err := retry.Do(ctx, backoff, operation); err != nil {
        // त्रुटि संभालें
    }
}

एक 1 सेकंड की प्रारंभिक मूल्य के साथ एक फिबोनाची बैकऑफ़ के साथ, प्रयास 1 सेकंड, 1 सेकंड, 2 सेकंड, 3 सेकंड, 5 सेकंड, आदि के बाद होंगे, फिबोनाची श्रृंखला का पालन करते हुए।

अध्याय 4: उन्नत पुन:प्रायास तकनीक और मिडलवेयर

4.1 पुन:प्रायास में जिटर का उपयोग

पुन:प्रायास तकनीक को लागू करते समय, सिस्टम पर समसामयिक पुन:प्रायास के प्रभाव को ध्यान में रखना महत्वपूर्ण है, जो एक थंडरिंग हर्ड समस्या में ले सकता है। इस समस्या को कम करने के लिए, हम पीछे के अंतरालों में यादृच्छिक जिटर जोड़ सकते हैं। यह तकनीक पुन:प्रायास की कोशिशों को विभाजित करने में मदद करती है, एकाधिक ग्राहकों के समान समय पुन:प्रायास की संभावना को कम करती है।

जिटर जोड़ने का उदाहरण:

b := retry.NewFibonacci(1 * time.Second)

// अगले मूल्य को लौटाएं, +/- 500ms
b = retry.WithJitter(500 * time.Millisecond, b)

// अगले मूल्य को लौटाएं, परिणाम का +/- 5%
b = retry.WithJitterPercent(5, b)

4.2 अधिकतम पुन:प्रायास सेट करना

कुछ परिदृश्यों में, पुर्न प्रयासों की संख्या को सीमित करना आवश्यक होता है, असक्षम और अप्रभावी पुन:प्रायासों से बचने के लिए। अधिकतम पुन:प्रायास संकेतित करने के लिए, हम क्रिया से पहले कितने पुन:प्रायास करना है यह नियंत्रित कर सकते हैं।

अधिकतम पुन:प्रायास को सेट करने का उदाहरण:

b := retry.NewFibonacci(1 * time.Second)

// 4 पुन:प्रायासों के बाद रोकें, जब 5वां प्रयास असफल हो गया है
b = retry.WithMaxRetries(4, b)

4.3 व्यक्तिगत पुन:प्रायास अवधियों का प्रतिबंधन

यह सुनिश्चित करने के लिए कि व्यक्तिगत पुन:प्रायास अवधियाँ किसी निश्चित सीमा से अधिक न हो, हम CappedDuration मिडलवेयर का उपयोग कर सकते हैं। यह अत्यधिक लंबी पुन:प्रायास अंतरालों को निर्धारित करने से बचाता है, पुन:प्रायास व्यवहार में पूर्वानुमानितता जोड़ता है।

व्यक्तिगत पुन:प्रायास अवधियों को प्रतिबंधित करने का उदाहरण:

b := retry.NewFibonacci(1 * time.Second)

// सुनिश्चित करें कि अधिकतम मान 2 सेकंड है
b = retry.WithCappedDuration(2 * time.Second, b)

4.4 कुल पुन:प्रायास अवधि नियंत्रण

ऐसे परिदृश्यों में जहां पूरे पुन:प्रायास प्रक्रिया के लिए कुल अवधि पर प्रतिबंध लगाना चाहिए, WithMaxDuration मिडलवेयर का उपयोग करके एक अधिकतम कुल क्रियान्वयन समय की निर्धारण किया जा सकता है। यह सुनिश्चित करता है कि पुन:प्रायास प्रक्रिया अनिश्चितता से नहीं चलती, पुन:प्रायास के लिए समय बजट लगाता है।

कुल पुन:प्रायास अवधि नियंत्रण का उदाहरण:

b := retry.NewFibonacci(1 * time.Second)

// सुनिश्चित करें कि अधिकतम कुल पुन:प्रायास समय 5 सेकंड है
b = retry.WithMaxDuration(5 * time.Second, b)