🔃 🗺️ 🖐🏼 सबसे अच्छे तरीके से आईपी पते की सूची को संपीड़ित करें 🔪 🆕 👩🏾‍🌾

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

सूची से नेटवर्क के अलावा, पड़ोसी नेटवर्क के सबसे बड़े सामान्य सबनेट को इस ग्राफ में जोड़ा जाता है। इसकी आवश्यकता क्यों है, इसके लिए आगे पढ़ें।

यह मई 2018 में Roskomnadzor से एक नेटवर्क ट्री की तरह लग रहा था।

सबसे पहले, मैंने पूरी सूची को जोड़ने की कोशिश की / ip मार्ग को मेरे MikroTik hAP ac lite में जोड़ने के लिए - राउटर डिस्क स्थान से बाहर चला गया। फिर मैंने सभी पते को बीजीपी के माध्यम से मेमोरी में लोड किया - राउटर ने थोड़ा काम किया और लटका दिया। यह स्पष्ट हो गया कि सूची को छंटनी की आवश्यकता है।

इस लेख में नेटवर्क-सूची-पार्सर उपयोगिता का असंसदीय से उल्लेख किया गया है । वह वही करती है जो मुझे चाहिए, लेकिन मैंने अपनी बाइक का आविष्कार करने के बाद उसे देखा। फिर मैंने इसे दिलचस्पी से खत्म कर दिया, क्योंकि मैंने जो बेहतर काम किया, वह बहुत धीमा था।

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

आइए सभी स्रोत नेटवर्क (ऊपर चित्र में क्या है) का ग्राफ बनाकर शुरू करें। रूट नोड नेटवर्क 0.0.0.0/0 होगा। एक नया सबनेट ए जोड़ते समय, हम पेड़ में सबनेट बी पाते हैं ताकि ए और बी सबनेट सी पर हों और सबनेट सी का आकार न्यूनतम (अधिकतम मुखौटा) हो। दूसरे शब्दों में, सबनेट ए और बी के आम बिट्स की संख्या अधिकतम होनी चाहिए। हम इस सामान्य सबनेट को पेड़ से जोड़ते हैं, और अंदर हम सबनेट ए और बी को स्थानांतरित करते हैं शायद इसे बाइनरी ट्री कहा जा सकता है।

उदाहरण के लिए, दो सबनेट (192.168.0.1/32 और 192.168.33.0/24) के एक पेड़ का निर्माण करें:

वृक्ष प्राप्त करें:

यदि हम कहते हैं, कहते हैं, नेटवर्क 192.168.150.150/32, तो पेड़ इस तरह दिखेगा:

ऑरेंज पेड़ के निर्माण के दौरान जोड़े गए आम सबनेट को इंगित करता है। यह इन सामान्य सबनेट है कि हम सूची के आकार को कम करने के लिए "पतन" करेंगे। उदाहरण के लिए, यदि आप 192.168.0.0/16 नोड को ध्वस्त करते हैं, तो हम नेटवर्क की सूची 2 के आकार को कम कर देंगे (मूल सूची से 3 नेटवर्क थे, यह 1 हो गया), लेकिन साथ ही हम इसके अतिरिक्त 6555-1-1-256 = 65278 आईपी पते कवर करते हैं, जो हमारी मूल सूची में शामिल नहीं है।

प्रत्येक नोड के लिए "पतन से लाभ के गुणांक" की गणना करना सुविधाजनक है, सूची से हटाए गए प्रत्येक प्रविष्टियों में अतिरिक्त रूप से जोड़े जाने वाले आईपी पते की संख्या दिखाते हुए:

weight_reversed = net_extra_ip_volume / (in_list_records_count - 1)

हम के रूप में वजन = 1 / weight_reversed का उपयोग करेंगे यह अधिक सुविधाजनक है। यह उत्सुक है कि वजन अनंत के बराबर हो सकता है यदि, उदाहरण के लिए, सूची में दो / 32 नेटवर्क हैं, जो एक साथ एक बड़े / 31 नेटवर्क बनाते हैं।

इस प्रकार, अधिक से अधिक वजन, इस तरह के एक नेटवर्क को खत्म करने के लिए अधिक लाभदायक है।

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

उदाहरण के लिए, हमारे पास एक पेड़ है जिसकी गणना की गई है:

आइए, सबनेट 192.168.0.0/30 को संक्षिप्त करें:

मूल नोड का वजन कम हो गया है। यदि 0.166 से अधिक वजन वाले पेड़ में नोड्स हैं, तो निम्नलिखित को ढह जाना चाहिए।

नतीजतन, सूची को पुनरावर्ती रूप से संकुचित करना पड़ता है। एल्गोरिथ्म कुछ इस तरह है:

हम सभी नोड्स के लिए वजन की गणना करते हैं।
प्रत्येक नोड के लिए, बच्चे के नोड (Wmax) का अधिकतम वजन स्टोर करें।
यह पता चलता है कि रूट नोड का Wmax पूरे पेड़ में नोड का अधिकतम वजन है (Wmax के बराबर वजन के साथ कई नोड हो सकते हैं)।
रूट नोड के Wmax के बराबर वजन के साथ सभी नेटवर्क को पुन: संकुचित करें। इस मामले में, हम वजन को पुनर्गणना करते हैं। हम रूट नोड पर लौटते हैं।
रूट नोड का Wax कम हो गया है - हम चरण 4 का प्रदर्शन करते हैं जब तक कि हमें नेटवर्क की सूची का वांछित आकार नहीं मिलता है।

सबसे दिलचस्प बात यह है कि एल्गोरिथ्म को गति में देखना है। यहाँ नेटवर्क की एक सूची के लिए एक उदाहरण है:

192.168.0.1
192.168.0.2
192.168.0.8/29
192.168.150.1
192.168.150.2
192.168.150.8/29
192.168.20.1
192.168.20.2
192.168.20.3
192.168.20.4
192.168.20.5
192.168.20.6
192.168.20.7

यहां, सबनेट 192.168.0.0/24 और 192.168.150.0/24 संरचना में समान हैं - यह देखना बेहतर है कि एल्गोरिथ्म संपीड़न के दौरान एक शाखा से दूसरी शाखा में कैसे कूदता है। उन्होंने 192.168.20.0/24 सबनेट को यह दिखाने के लिए जोड़ा कि यह कभी-कभी बाल नेटवर्क की तुलना में मूल नेटवर्क को संपीड़ित करने के लिए अधिक लाभदायक है। सबनेट 192.168.20.0/30 पर ध्यान दें: पेड़ को भरने के बाद उसका वजन मूल सबनेट से कम होता है।

पेड़ भरने:

यहां ब्लैक फॉन्ट मूल सूची से वास्तविक नेटवर्क है। पीला - जोड़ा नेटवर्क। ब्लू नोड का वजन है। लाल वर्तमान नेटवर्क है। गुलाबी ढला हुआ जाल है।

संपीड़न:

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

अब यह बीजीपी के बारे में लेख से नेटवर्क-सूची-पार्सर के साथ तुलना करने के लिए बना हुआ है।

मेरी स्क्रिप्ट के पेशेवरों:

अधिक सुविधाजनक सेटअप: केवल नेटवर्क की सूची के आवश्यक आकार को निर्दिष्ट करें, और आउटपुट बिल्कुल उस आकार की एक सूची होगी। नेटवर्क-सूची-पार्सर में बहुत सारे हैंडल हैं, और आपको उनमें से एक संयोजन खोजने की आवश्यकता है।
संपीड़न अनुपात मूल सूची में बदल जाता है। यदि हम सूची से कुछ नेटवर्क हटाते हैं, तो हमें अधिक पते मिलेंगे, यदि हम अधिक जोड़ते हैं। इस स्थिति में, परिणामी सूची का आकार स्थिर रहेगा। आप अधिकतम आकार चुन सकते हैं जो राउटर को संभाल सकता है, और कुछ बिंदु पर सूची के बहुत बड़े होने की चिंता न करें।
परिणामी सूची में अतिरिक्त नेटवर्क की न्यूनतम संभव संख्या शामिल है। गिटहब से परीक्षण सूची में, मेरे एल्गोरिथ्म ने 718479 अतिरिक्त आईपी पते, और नेटवर्क-सूची-पार्सर - 798761 दिया । अंतर केवल 10% है ।
मैंने इसकी गणना कैसे की? नज़र
1. लॉन्च
```
  ./network-list-parser-darwin-386-1.2.bin -src-file real_net_list_example.txt -dst-file parsed.txt -aggregation-max-fake-ips 0 -intensive-aggregation-min-prefix 31 2>&1 
```
और हमें कचरे के बिना एक साफ सूची प्राप्त होती है और आंशिक रूप से कम हो जाती है। मैं parsed.txt की संपीड़न गुणवत्ता की तुलना करूंगा। (इस कदम के बिना, यह मूल्यांकन करने में समस्याएं थीं कि कितने नकली आईपी नेटवर्क-सूची-पार्सर जोड़ता है)।

2. लॉन्च
```
 ./network-list-parser-darwin-386-1.2.bin -src-file parsed.txt -dst-file parsed1.txt 2>&1 
```
और हम एक संकुचित सूची प्राप्त करते हैं, आउटपुट को देखते हैं, वहाँ लाइन है "7.3% आईपी कवरेज (798761) जोड़ें।"

Parsed1.txt फ़ाइल में 16649 प्रविष्टियाँ हैं।

3. लॉन्च

python3 minim_net_list.py parsed.txt 16649।
हम लाइन ### नहीं असली ips देखें: 718479।

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

सामान्य तौर पर, यह पूर्णतावादियों के लिए इस योजना का उपयोग करने के लिए समझ में आता है, क्योंकि सभी अन्य 10% सहेजे गए नेटवर्क के लिए इतना कंप्यूटिंग संसाधन खर्च करने की संभावना नहीं है। खैर, थोड़ा और सुविधाजनक, हाँ।

GitHub पर परियोजना के लिए लिंक

इस तरह से चलाएं:

 python3 minimize_net_list.py real_net_list_example.txt 30000 | grep -v ### > result.txt

वह, वास्तव में, सब है।

युपीडी
टिप्पणियों में पोकेमुक ने वजन की गणना करने में त्रुटि का संकेत दिया, मैंने इसे ठीक कर दिया और अब, जब समान सेटिंग्स के साथ उदाहरण से समान सूची को संपीड़ित करते हैं, तो 624925 आईपी पते जोड़े जाते हैं जो मूल सूची में शामिल नहीं हैं। नेटवर्क-सूची-पार्सर को संसाधित करते समय यह पहले से ही 22% बेहतर है
अप्राप्त github.com/phoenix-mstu/net_list_minimizer/tree/untested शाखा में नया कोड

सबसे अच्छे तरीके से आईपी पते की सूची को संपीड़ित करें

More articles: