नेटफ्लिक्स में अनुकूली सीमाएं

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

आइए बुनियादी बातों से शुरू करें

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



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



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

निर्णय

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

1. मैनुअल काम की आवश्यकता नहीं थी;
   
2. केंद्रीय समन्वय की आवश्यकता नहीं थी;
   
3. हार्डवेयर या सिस्टम टोपोलॉजी के बारे में किसी भी जानकारी के बिना सीमा निर्धारित कर सकता है;
   
4. सिस्टम टोपोलॉजी में परिवर्तन के लिए अनुकूल;
   
5. कार्यान्वयन और आवश्यक गणना के संदर्भ में सरल था।
   

इस समस्या को हल करने के लिए, हम सिद्ध टीसीपी भीड़ ट्रैकिंग एल्गोरिथ्म में बदल गए। यह एल्गोरिथ्म उन डेटा पैकेटों की संख्या निर्धारित करता है जिन्हें देरी के समय को बढ़ाए या प्रतीक्षा समय से अधिक किए बिना समानांतर (यानी, अतिप्रवाह खिड़की के आकार) में प्रेषित किया जा सकता है। ये एल्गोरिदम एक साथ प्रेषित पैकेट की सीमा निर्धारित करने और तदनुसार अतिप्रवाह विंडो का आकार बदलने के लिए विभिन्न संकेतकों का उपयोग करते हैं।



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

हमारा एल्गोरिथ्म टीसीपी भीड़ पर नज़र रखने वाले एल्गोरिथ्म पर निर्भर करता है, जो न्यूनतम विलंब समय (सबसे अच्छा संभावित परिदृश्य जिसमें कतार का उपयोग नहीं किया जाता है) और विलंब समय के बीच संबंध पर विचार करता है, जिसे समय-समय पर अनुरोधों के रूप में मापा जाता है। यह अनुपात यह निर्धारित करना संभव बनाता है कि एक कतार बनाई गई है जो देरी में वृद्धि को भड़काती है। यह अनुपात हमें देरी समय परिवर्तन का ढाल या परिमाण देता है: ढाल = (RTTnoload / RTTactual) । यदि मान एक के बराबर है, तो हम समझते हैं कि कोई कतार नहीं है और सीमा बढ़ाई जा सकती है। एक से कम मूल्य इंगित करता है कि कतार भरी हुई है और सीमा को कम करने की आवश्यकता है। देरी के समय के प्रत्येक नए माप के साथ, सीमा को उपरोक्त अनुपात के आधार पर समायोजित किया जाता है, और इसके साथ इस सरल सूत्र के अनुसार स्वीकार्य कतार आकार बदलता है:

_ = _ ×  + _ 

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

कार्रवाई में अनुकूली सीमाएं

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



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

निष्कर्ष

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

हम आपको हमारे कार्यान्वयन के तरीकों और इस समाधान के समग्र एकीकरण के साथ साझा करने की कृपा कर रहे हैं, जिसे आप सार्वजनिक पुस्तकालय github.com/Netflix/concurrency-limits पर पा सकते हैं। हमें उम्मीद है कि हमारा कोड उपयोगकर्ताओं को अपनी सेवाओं को कैस्केडिंग विफलताओं और बढ़ती विलंबता के साथ समस्याओं से बचाने में मदद करेगा, साथ ही उनकी उपलब्धता में वृद्धि करेगा।