MPP5 PPPoE सर्वर पर लोड संतुलन

तो चलिए शुरू करते हैं कच्चे डेटा से।
FreeBSD + MPD5 (PPPoE) पर आधारित 4 NAS सर्वरों के साथ एक ISP है और सर्वर पर लोड को सामान्य करने के लिए कार्य है।
शुरू करने के लिए, आइए सर्वर लोड BEFORE सामान्यीकरण के ग्राफ पर एक नज़र डालें:


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

सामान्यीकरण तकनीक

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

एल्गोरिथ्म

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

nases = [ ('VPN2',('192.168.X.Y','5001','username','password',600)), ('VPN3',('192.168.X.Y1','5001','username','password',300)), ('VPN4',('192.168.X.Y2','5001','username','password',600)), ('VPN5',('192.168.X.Y3','5001','username','password',200)) ] 

जहां क्रमशः पैरामीटर हैं:
सर्वर का नाम, पता, पोर्ट, एमपीडी प्रशासक का नाम, पासवर्ड, सामान्यीकरण कारक (वास्तव में, यह समानांतर सत्रों की अधिकतम संख्या है जो सर्वर समर्थन करता है)

एल्गोरिथ्म का सार इस प्रकार है:

1. हम निर्धारित करते हैं कि सभी सर्वर काम कर रहे हैं (यदि एक या कई सर्वर गिर गए हैं - हम दूसरों के अनुपात में उनके गुणांक को फिर से वितरित करते हैं)
2. हम प्रत्येक आइटम की पूर्णता के प्रतिशत की गणना करते हैं, खाता संख्या 1 में लेते हैं
3. प्रतिशत पूर्णता के अवरोही क्रम में सूची को क्रमबद्ध करें।
4. एन सबसे अधिक आबादी वाले सर्वर को बंद करें और बाकी को उपलब्ध करें।

कार्यान्वयन के बिंदुओं पर:
1. उपयोगकर्ताओं की संख्या निर्धारित करें:

 def getUserCount(anas): (nas,params) = anas (host,port,user,pwd,koeff) = params try: client = telnetlib.Telnet(host,port) client.read_until("Username:") client.write(user+'\n') client.read_until("Password:") client.write(pwd+'\n') client.read_until("[]") client.write("sh mem \n") res = int(client.read_until("BUND").split('\n')[3].split()[1]) dummy = client.read_until("[]") client.write("sh global \n") limit=int(client.read_until("Global options").split("\n")[10].split()[2]) client.close() return (nas,(res,limit),params) except: return (nas,(0,0),params) ress = map(getUserCount,nases) 

2. हम सभी सर्वरों के गुणांक का योग मानते हैं।

 naskcount = reduce(lambda total,nas: total+nas[1][4],nases,0) 

3. हम c.1 में प्राप्त सूची से ऑनलाइन सभी उपयोगकर्ताओं के योग की गणना करते हैं:

 naswcount = reduce(lambda total,nas: total+(((nas[1][0] != 0) and nas[2][4]) or 0),ress,0) 

4. उन गुणकों के गुणांक को ध्यान में रखते हुए नए गुणांक को निर्धारित करें जो गिर सकते हैं ( new_koeff = koeff * (nascount / naswcount) ):

 def corKoeff(nas): (nas,(klk,limit),params) = nas (host,port,user,pwd,koeff) = params koeff = koeff * ((klk != 0 ) and (float(naskcount)/float(naswcount)) or 0) params = (host,port,user,pwd,int(round(koeff,0))) return (nas,(klk,limit),params) ress1 = map(corKoeff,ress) 

5. सर्वर अधिभोग के प्रतिशत की गणना करें ( प्रतिशत = 100% * klk / koeff ) और सॉर्ट करें:

 def calcMaxUser(nas): (nas,(klk,limit),params) = nas (host,port,user,pwd,koeff) = params return (nas,klk,(koeff !=0 and float(100*klk)/float(koeff)) or 0,params) ress2 = map(calcMaxUser,ress1) ress2.sort(lambda x,y: cmp(x[2],y[2])) 

अब हम "अपने कानों के साथ एक फिंट" बनाते हैं (हम 2 कम लोड वाले कारकों को छोड़कर सभी सर्वरों के लिए -1 प्रतिस्थापित करते हैं (मैं व्यक्तिगत रूप से इस दृष्टिकोण को पसंद नहीं करता, लेकिन मैं नहीं जानता कि इसे और अधिक "सांस्कृतिक" कैसे बनाया जाए):

 for i in range(-1,-len(ress2)+1,-1): (nas,klk,koeff,params) = ress2[i] koeff = -1 ress2[i] = (nas,klk,koeff,params) 

उसके बाद, ress2 में, हमारे पास पहले से ही सब कुछ है जिसे हमें mpd में अधिकतम-बच्चों को स्थापित करने की आवश्यकता है। हम वास्तव में क्या कर रहे हैं (सर्वरों के लिए -1 चिह्नित हमने अधिकतम संख्या 10,000 तक निर्धारित की है, और अन्य सभी उपयोगकर्ताओं की वर्तमान संख्या के बराबर है - 10% (सिर्फ गुणांक सिर से लिया जा सकता है, मुख्य बात यह नहीं है कि जुड़े उपयोगकर्ताओं की वर्तमान संख्या से अधिक हो):

 def setMax(nas): (nas,klk,koeff,params) = nas (host,port,user,pwd,kkx) = params if koeff != -1: klk = 10000 else: klk = round(klk * float(100-down_koeff)/float(100)) try: client = telnetlib.Telnet(host,port) client.read_until("Username:") client.write(user+'\n') client.read_until("Password:") client.write(pwd+'\n') client.read_until("[]") client.write("set global max-children %d\n" % klk) client.close() return (nas,"max set to %d" % klk) except: return (nas,"Error setting max-children %d" % klk) 

परिणाम

नतीजतन, इस स्क्रिप्ट को क्रोन में स्थापित करने के बाद, हमें इस तरह का सामान्यीकरण मिला

ब्लू-ब्राउन लगभग उसी तरह से जाते हैं। क्या हासिल करना जरूरी था

पुनश्च
अजगर में टेलनेट के साथ काम करने के मुद्दों पर: यहाँ
mpd5 पैरामीटर (रूसी में): यहां
R.R.S.

काम करते समय, डमी = client.read_until ("[]") के लिए टेलनेट आउटपुट को "पढ़ना" आवश्यक रूप से न भूलें, अन्यथा अप्रत्याशित परिणाम होंगे (उदाहरण के लिए, कमांड जो काम नहीं किए थे)

UPD: नाम को और बदल दिया (धन्यवाद obramko ) यह था: " MPD5 वीपीएन सर्वर पर लोड को सामान्य करने के लिए राउंड-रॉबिन "
व्यवस्थापक से UPD_1: " विवादास्पद " NAS-s के बारे में कुछ स्पष्टीकरण:
भूरे रंग:
FreeBSD 8.2-RELEASE-p1 #1: Fri May 13 22:55:37 EEST 2011
CPU: Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz (3363.89-MHz K8-class CPU)
Origin = "GenuineIntel" Id = 0x106e5 Family = 6 Model = 1e Stepping = 5 Features=0xbfebfbff <FPU,VME,DE,PSE,TSC,MSR,PAE,MCE,CX8,APIC,SEP,MTRR,PGE,MCA,CMOV,PAT,PSE36,CLFLUSH,DTS,ACPI,MMX,FXSR,SSE,SSE2,SS,HTT,TM,PBE > Features2=0x98e3fd <SSE3,DTES64,MON,DS_CPL,VMX,SMX,EST,TM2,SSSE3,CX16,xTPR,PDCM,SSE4.1,SSE4.2,POPCNT >
AMD Features=0x28100800 <SYSCALL,NX,RDTSCP,LM>
AMD Features2=0x1<LAHF>
TSC: P-state invariant
real memory = 2147483648 (2048 MB)
avail memory = 2041532416 (1946 MB)



नीले रंग:
FreeBSD 8.2-RELEASE-p1 #1: Fri May 13 22:55:37 EEST 2011
Timecounter "i8254" frequency 1193182 Hz quality 0
CPU: Intel(R) Core(TM) i7 CPU 920 @ 2.67GHz (2664.79-MHz K8-class CPU)
Origin = "GenuineIntel" Id = 0x106a5 Family = 6 Model = 1a Stepping = 5 Features=0xbfebfbff < FPU,VME,DE,PSE,TSC,MSR,PAE,MCE,CX8,APIC,SEP,MTRR,PGE,MCA,CMOV,PAT,PSE36,CLFLUSH,DTS,ACPI,MMX,FXSR,SSE,SSE2,SS,HTT,TM,PBE >
Features2=0x98e3bd < SSE3,DTES64,MON,DS_CPL,VMX,EST,TM2,SSSE3,CX16,xTPR,PDCM,SSE4.1,SSE4.2,POPCNT >
AMD Features=0x28100800 <SYSCALL,NX,RDTSCP,LM >
AMD Features2=0x17<LAHF>
TSC: P-state invariant
real memory = 4294967296 (4096 MB)
avail memory = 4106272768 (3916 MB)


दोनों मामलों में, एलएजीजी का उपयोग 2 ईएमएस पर ग्राहकों के साथ संवाद करने के लिए किया जाता है और प्रत्येक को दुनिया तक पहुंच प्रदान की जाती है।
अंतर CPU और RAM में है।
मैं सर्वरों की दुर्भावना को भ्रामक करने के लिए लोगों से माफी माँगता हूँ। BUT सिद्धांत रूप में, वे उपरोक्त तकनीक का उपयोग करते समय सामान्य रूप से उपयोगकर्ताओं की समान संख्या रखते हैं। इसलिए, मैं इस नोट को उपयोगी मानता हूं और आपकी टिप्पणियों के लिए तत्पर हूं।

व्यवस्थापक से UPD_2 : वे कारण जिन्होंने हमें इस पद्धति को विकसित करने के लिए प्रेरित किया।
यह सिर्फ इतना हुआ कि ज्यादातर ग्राहक सुबह कनेक्ट करते हैं लेकिन शाम 6-7 बजे डाउनलोड करना शुरू करते हैं।
सामान्यीकरण के बिना, "ब्लू" एनएएस अधिकांश कनेक्शन लेता है। और आम तौर पर चोटी तक उनके साथ काम करता है। और 6-7 घंटों के बाद से अधिकांश ग्राहक 15-20 Mbit पर डाउनलोड करना शुरू करते हैं, यह इसे नहीं खड़ा करता है और हर 2 सप्ताह में लगभग एक बार आतंकित करता है। सामान्यीकरण की यह विधि ग्राहकों द्वारा घंटे X से पहले भी हमारे द्वारा निर्धारित गुणांक के अनुसार स्कैटर करती है, जिससे ग्राहकों को अधिक विश्वसनीय संचार प्रदान होता है और अतिरिक्त दो घंटे की नींद का समर्थन करता है।