🐳 🧑🏾 🙎🏻 लिनक्स पर इनबाउंड और आउटबाउंड ट्रैफिक को सीमित करें 👩🏿 👹 👲🏾

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

यातायात को सीमित करने के तरीके क्या हैं?

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

मेरे कार्यों के आधार पर, बैंडविड्थ को सीमित करने के लिए निम्न विधियों का उपयोग किया जा सकता है:
1. स्क्वीड प्रॉक्सी का उपयोग करके प्रतिबंध।
यह विधि आपको लचीले ढंग से बैंडविड्थ को सीमित करने की क्षमता के साथ सभी www, एफ़टीपी उपयोगकर्ता यातायात को नियंत्रित करने की अनुमति देती है।
2. iproute2 से ट्रैफिक कंट्रोल का उपयोग करना।
यातायात को प्रतिबंधित करने का एक बहुत ही लचीला और इष्टतम तरीका है, लेकिन पिछले पद्धति की तरह, WWW यातायात पर नियंत्रण प्रदान नहीं करता है।
3. बेशक, iptables के लिए –m सीमा मॉड्यूल का उपयोग करके गति को सीमित करना संभव है - लेकिन मैं इसे अस्वीकार्य मानता हूं।

सामान्य तौर पर, मैंने iproute2 पैकेज का उपयोग करके यातायात को सीमित करने की विधि पर ध्यान केंद्रित करने का निर्णय लिया।

क्या, कहाँ और कैसे?

जैसा कि पहले ही उल्लेख किया गया है, मैं सर्वर का उपयोग करता हूं: ओएस उबंटू 10.04, कर्नेल 2.6.32-30। सर्वर में 3 इंटरफेस हैं: eth0 - आंतरिक नेटवर्क, eth1 - प्रदाता 1, eth2 - प्रदाता 2।

उद्देश्य: कुछ शर्तों के आधार पर, कक्षाओं द्वारा यातायात की प्राथमिकता के साथ आने वाले और बाहर जाने वाले उपयोगकर्ता यातायात की गति को सीमित करना। स्थानीय यातायात को सीमित न करें।

सिद्धांत की बिट

ऐसी स्थिति की कल्पना करें जहां एक उपयोगकर्ता ने youtube.com के साथ संबंध स्थापित किया है और एचडी गुणवत्ता में कुछ वीडियो देख रहा है। अधिकांश ट्रैफ़िक सर्वर से जाता है, इस मामले में उपयोगकर्ता को youtube.com। यह देखते हुए कि सभी ट्रैफ़िक हमारे प्रवेश द्वार से गुजरते हैं, हम आंतरिक ट्रैफ़िक इंटरफ़ेस पर ट्रैफ़िक शेपर स्थापित करके इस ट्रैफ़िक की प्रसारण गति को प्रभावित कर सकते हैं।
इसी तरह की स्थिति तब होती है जब उपयोगकर्ता छुट्टी पर एक फोटो रिपोर्ट अपलोड करता है, जिसमें 5000x3500 पिक्सल के एक संकल्प में 300 फोटो शामिल होते हैं, कुछ ऑनलाइन फोटो स्टोरेज सेवा के लिए।

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

क्लाइंट से आउटगोइंग ट्रैफ़िक को प्रतिबंधित करने की समस्या को हल करने के लिए, मैंने एक IFB डिवाइस का उपयोग किया, जिसने क्लाइंट से सभी आउटगोइंग ट्रैफ़िक को रीडायरेक्ट किया।

यातायात प्रबंधन सिद्धांत में, हम केवल आउटगोइंग ट्रैफ़िक को प्रतिबंधित कर सकते हैं। इसलिए, आंतरिक नेटवर्क के उपयोगकर्ता को निर्देशित किया गया ट्रैफ़िक आंतरिक इंटरफ़ेस eth0 के सापेक्ष आउटगोइंग हो जाएगा, और आंतरिक नेटवर्क के उपयोगकर्ता से भेजा गया ट्रैफ़िक बाहरी इंटरफ़ेस eth1 के सापेक्ष आउटगोइंग हो जाएगा।

पूर्वगामी के आधार पर, मैंने आंतरिक नेटवर्क इंटरफ़ेस पर उपयोगकर्ता के लिए आने वाले ट्रैफ़िक को eth0 और सीमित उपयोगकर्ता को आने वाले ट्रैफ़िक को ifb0 वर्चुअल इंटरफ़ेस तक सीमित कर दिया।

ताकि किसी भी बड़ी मात्रा में डेटा डाउनलोड करने के लिए गेटवे पर उसके द्वारा सीमित संपूर्ण बैंडविड्थ के उपयोगकर्ता के कब्जे के दौरान, वह सामान्य रूप से ssh का उपयोग कर सके और इसलिए कि उसके लिए पिंग काम करता है, मैंने ट्रैफ़िक प्राथमिकता का उपयोग किया।

मैंने निम्नलिखित ट्रैफ़िक को प्राथमिकता दी:

ICMP
udp, ssh
टीसीपी स्पोर्ट 80
बाकी अवर्गीकृत यातायात

पैरामीटर जितना कम होगा, यातायात की प्राथमिकता उतनी ही अधिक होगी।

अनुशासन, कक्षाएं, फिल्टर

जैसा कि मैंने पहले ही नोट किया है, उपयोगकर्ताओं के लिए आने वाले ट्रैफ़िक eth0 इंटरफ़ेस पर सीमित होंगे, और उपयोगकर्ताओं से आउटगोइंग ट्रैफ़िक - ifbb वर्चुअल इंटरफ़ेस पर।

Ifb0 इंटरफ़ेस को आरंभ करने के लिए, आपको पहले इंटरफ़ेस नियंत्रण मॉड्यूल लोड करना होगा:
/sbin/modprobe ifb
मॉड्यूल को सफलतापूर्वक लोड करने के बाद, आपको इंटरफ़ेस को सक्षम करने की आवश्यकता है:
/sbin/ip link set dev ifb0 up
फिर, इंटरफ़ेस हटा दिए जाने के बाद, आपको उपयोगकर्ताओं से सभी आउटगोइंग ट्रैफ़िक को इस इंटरफ़ेस पर पुनर्निर्देशित करना होगा:

/sbin/tc qdisc add dev eth0 ingress
/sbin/tc filter add dev eth0 parent ffff: protocol ip u32 match u32 0 0 action mirred egress redirect dev ifb0

अब आप eth0 इंटरफ़ेस पर उपयोगकर्ताओं के लिए आने वाले ट्रैफ़िक और ifb0 इंटरफ़ेस पर आउटगोइंग ट्रैफ़िक के लिए सुरक्षित रूप से कक्षाएं और फ़िल्टर बनाना शुरू कर सकते हैं।

निम्नलिखित सिद्धांत का उपयोग यातायात को सीमित करने के लिए किया जाता है:

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

वर्गों को नस्ट किया जा सकता है। यही है, अगर कक्षा 1: 1 Mbit की अधिकतम बैंडविड्थ का वर्णन करता है, तो कक्षा 1: 1, जो इसका उपवर्ग है, अपने माता-पिता की गति सीमा से अधिक नहीं हो सकती।

उपयोगकर्ताओं के लिए आने वाले यातायात को सीमित करें

सभी यातायात जोड़तोड़ eth0 इंटरफ़ेस पर किए जाएंगे।

सबसे पहले, इंटरफ़ेस पर रूट कतार हैंडलर बनाएं:
/sbin/tc qdisc add dev eth0 root handle 1: htb default 900

इस प्रकार, हमने रूट कतार हैंडलर को eth0 इंटरफ़ेस से जोड़ा, इसे नंबर 1 सौंपा: और सभी अवर्गीकृत ट्रैफ़िक को कक्षा 900 में भेजने के साथ HTB अनुसूचक के उपयोग की ओर इशारा किया।

फिर इंटरफेस स्पीड के बराबर चैनल चौड़ाई के साथ 1: 1 चाइल्ड क्लास बनाएं:
/sbin/tc class add dev eth0 parent 1: classid 1:1 htb rate 100Mbit burst 15k
बाद के सभी वर्ग उस वर्ग के उपवर्ग होंगे जो हमने अभी बनाए हैं। यह हमें डेटा प्रवाह दरों की अधिक सटीक प्राथमिकता और प्रसंस्करण प्रदान करता है।

आइए स्थानीय ट्रैफ़िक के लिए एक क्लास बनाएं, गंतव्य का पता या स्रोत का पता जिसमें सर्वर का आंतरिक पता होगा। यह एसएसएच, एसएमबी, एफटीपी, डब्ल्यूडब्ल्यूडब्ल्यू जैसे सर्वर संसाधनों का उपयोग करने की सुविधा के लिए आवश्यक है। वर्ग द्वारा वर्णित गति 50Mbit है, लेकिन यदि मूल वर्ग की प्रवाह दर 100Mbit से कम नहीं है, तो हम अधिकतम डेटा अंतरण गति के रूप में 80Mbit का उपयोग करने की अनुमति देते हैं।
/sbin/tc class add dev eth0 parent 1:1 classid 1:10 htb rate 50Mbit ceil 80Mbit burst 15k

अगला, हम एक वर्ग बनाते हैं जिसकी गति उस बैंडविड्थ के बराबर होगी जो प्रदाता हमें प्रदान करता है। मेरे मामले में, यह 15Mbit है।
/sbin/tc class add dev eth0 parent 1:1 classid 1:100 htb rate 15Mbit burst 15k

भले ही प्रदाता एक उच्च गति प्रदान करता है, उदाहरण के लिए 18Mbit, मैं एक "नरम" ट्रैफिक प्रतिबंध के लिए 1-2 Mbit द्वारा एक शेपर के लिए इस गति को कम करने की सलाह देता हूं।
अगला, हम एक वर्ग बनाते हैं, जिसमें सभी डेटा पैकेट जो पहले बनाए गए किसी भी वर्ग में नहीं आएंगे, भेजे जाएंगे।
/sbin/tc class add dev eth0 parent 1:1 classid 1:900 htb rate 56Kbit ceil 128Kbit

प्रत्येक उपयोगकर्ता के लिए, मैंने एक आबंटित बैंडविड्थ के साथ एक अलग उपवर्ग बनाया, और फिर इस वर्ग के उपवर्गों को बनाया है ताकि हम नेटवर्क को प्राथमिकता दें
/sbin/tc class add dev eth0 parent 1:100 classid 1:101 htb rate 4Mbit ceil 6Mbit

इस कमांड के साथ, हमने नंबर 1: 101 के साथ एक वर्ग के निर्माण की ओर इशारा किया, जो कि नंबर 1: 100 के साथ वर्ग का एक उपवर्ग है और 4Mbit में कक्षा की बैंडविड्थ को इंगित करता है, और मूल वर्ग से मुक्त बैंडविड्थ के मामले में, 6Mbit की गति से कक्षा के माध्यम से डेटा का अधिकतम पारित होने की अनुमति देता है।

अगला, हम ट्रैफ़िक को प्राथमिकता देने के लिए उपवर्ग बनाते हैं:

# PRIO 1 -> icmp traffic -
/sbin/tc class add dev eth0 parent 1:101 classid 1:102 htb rate 33kbit ceil 6Mbit prio 1
# PRIO 2 -> udp, ssh
/sbin/tc class add dev eth0 parent 1:101 classid 1:103 htb rate 33kbit ceil 6Mbit prio 2
# PRIO 3 -> tcp sport 80 – WWW
/sbin/tc class add dev eth0 parent 1:101 classid 1:104 htb rate 33kbit ceil 6Mbit prio 3
# PRIO 4 -> unclassified traffic – , ,
/sbin/tc class add dev eth0 parent 1:101 classid 1:105 htb rate 33kbit ceil 6Mbit prio 4

कक्षाएं बनाने के बाद, फ़िल्टर बनाने का समय है जो कुछ मानदंडों के अनुसार ट्रैफ़िक को वर्गीकृत करेगा।

यातायात को वर्गीकृत करने के कई तरीके हैं।
उनमें से सबसे सुविधाजनक u32 क्लासिफायर हैं , जो आपको गंतव्य या प्रेषक पते, उपयोग किए गए प्रोटोकॉल, पोर्ट नंबर और इसी तरह, और iptables लेबल के आधार पर क्लासिफायर के आधार पर पैकेट को वर्गीकृत करने की अनुमति देते हैं। उत्तरार्द्ध का उपयोग करने के लिए, आपको पहले कुछ शर्तों के आधार पर, PREROUTING श्रृंखला में iptables के साथ पैकेटों को चिह्नित करना होगा, और फिर वांछित कक्षाओं में संबंधित लेबल के साथ आगे के पैकेटों के लिए tc का उपयोग करना होगा।

मैंने u32 क्लासिफायर का उपयोग करना पसंद किया।

हम icmp के ट्रैफ़िक को सबसे कम प्राथमिकता देते हैं और इसे कक्षा 1: 102 पर भेजते हैं

/sbin/tc filter add dev eth0 protocol ip parent 1:0 prio 1 u32 match ip dst 192.168.10.78 \
match ip protocol 1 0xff flowid 1:102

यूडीपी और एसएसएच ट्रैफिक को कक्षा 1: 103 में भेजा जाता है

/sbin/tc filter add dev eth0 protocol ip parent 1:0 prio 2 u32 match ip dst 192.168.10.78 \
match ip protocol 17 0xff flowid 1:103
/sbin/tc filter add dev eth0 protocol ip parent 1:0 prio 2 u32 match ip dst 192.168.10.78 \
match ip protocol 6 0xff match ip sport 22 0xffff flowid 1:103

Tcp पोर्ट 80 से आने वाले WWW ट्रैफिक को क्लास 1: 104 पर भेजा जाता है

/sbin/tc filter add dev eth0 protocol ip parent 1:0 prio 3 u32 match ip dst 192.168.10.78 \
match ip protocol 6 0xff match ip sport 80 0xffff flowid 1:104

ट्रैफ़िक जो किसी भी स्थिति से मेल नहीं खाता है उसे कक्षा 1: 105 पर भेजा जाता है
/sbin/tc filter add dev eth0 protocol ip parent 1:0 prio 4 u32 match ip dst 192.168.10.78 flowid 1:105

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

आउटगोइंग ट्रैफिक को सीमित करें

उपयोगकर्ताओं से आने वाले ट्रैफ़िक को सीमित करने के लिए, आने वाले ट्रैफ़िक के लिए वही कार्य किए जाते हैं, जिनमें केवल ifb0 वर्चुअल इंटरफ़ेस का उपयोग किया जाता है। आपको निम्नलिखित ट्रैफ़िक के गंतव्य को भी बदलना होगा: dst 192.168.10.78 के बजाय, आपको क्रमशः src 192.168.10.78 निर्दिष्ट करने की आवश्यकता है।

स्वचालन और स्क्रिप्ट कैसे काम करती है

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

 root@mixer:/etc/rc.d/shape# cat ./users #CLIENT IP DOWN CEIL UP CEIL PROVIDER ID user1 192.168.10.78 1Mbit 2Mbit 1Mbit 4Mbit mageal 10 user2 192.168.10.44 1Mbit 1Mbit 2Mbit 3Mbit ukrtel 11

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

root@steel:/etc/rc.d/shape# cat ./rc.shape

#!/bin/bash
. /etc/init.d/functions
/sbin/modprobe ifb
/sbin/ip link set dev ifb0 up

TC="/sbin/tc"
DEV_P1_DOWN="eth0"
DEV_P1_UP="ifb0"

stop(){
$TC qdisc del dev $DEV_P1_DOWN root
$TC qdisc del dev $DEV_P1_UP root
$TC qdisc del dev $DEV_P1_DOWN ingress
}
start(){
#
$TC qdisc del dev $DEV_P1_DOWN root
$TC qdisc del dev $DEV_P1_UP root
$TC qdisc del dev $DEV_P1_DOWN ingress

## ifb0
$TC qdisc add dev $DEV_P1_DOWN ingress
$TC filter add dev $DEV_P1_DOWN parent ffff: protocol ip u32 match u32 0 0 action mirred egress redirect dev $DEV_P1_UP

#

. /etc/rc.d/shape/rc.shape.down.classes
. /etc/rc.d/shape/rc.shape.up.classes

# , 50 80.
$TC filter add dev $DEV_P1_UP protocol ip parent 1:0 prio 1 u32 match ip dst 10.0.0.1 flowid 1:10
$TC filter add dev $DEV_P1_DOWN protocol ip parent 1:0 prio 1 u32 match ip src 10.0.0.1 flowid 1:10

#
. /etc/rc.d/shape/rc.shape.filters
}

case "$1" in
start)
start
;;
stop)
stop
;;
restart|reload)
start
;;
*)
msg_usage "${0##*/} {restart|start|stop}"
RETVAL=1
esac

अगला कोड लोड किया गया है:

कक्षाएं

root@steel:/etc/rc.d/shape# cat ./rc.shape.down.classes

#!/bin/bash
## DOWNLOAD CLASSES
##########################################################
#
$TC qdisc add dev $DEV_P1_DOWN root handle 1: htb default 900

#
$TC class add dev $DEV_P1_DOWN parent 1: classid 1:1 htb rate 100Mbit burst 15k

# (SERVER -> CLIENTS)
$TC class add dev $DEV_P1_DOWN parent 1:1 classid 1:10 htb rate 50Mbit ceil 80Mbit burst 15k

# (SERVER -> CLIENTS)
$TC class add dev $DEV_P1_DOWN parent 1:1 classid 1:100 htb rate 15Mbit burst 15k

# (SERVER -> CLIENTS)
$TC class add dev $DEV_P1_DOWN parent 1:1 classid 1:900 htb rate 128Kbit ceil 128Kbit

root@steel:/etc/rc.d/shape# cat ./rc.shape.up.classes
#!/bin/bash

## UPLOAD CLASSES
#############################################################
#
$TC qdisc add dev ifb0 root handle 1: htb default 900

#
$TC class add dev ifb0 parent 1: classid 1:1 htb rate 100Mbit burst 15k
# (CLIENTS -> SERVER)
$TC class add dev $DEV_P1_UP parent 1:1 classid 1:10 htb rate 50Mbit ceil 80Mbit burst 15k

# (CLIENTS -> SERVER)
$TC class add dev $DEV_P1_UP parent 1:1 classid 1:100 htb rate 5Mbit burst 15k
# (CLIENTS -> SERVER)
$TC class add dev $DEV_P1_UP parent 1:1 classid 1:900 htb rate 128Kbit ceil 128Kbit

और फिल्टर:

root@steel:/etc/rc.d/shape# cat ./rc.shape.filters
#!/bin/bash
# “users”
while read LINE
do
set -- $LINE
if [[ $1 =~ '^\#' ]]
then
continue
fi
################################################################
CLIENT_IP=$2
CLIENT_DOWN_RATE=$3
CLIENT_DOWN_CEIL=$4
################################################################
# DOWNSTREAM
#####################

#
$TC class add dev $DEV_P1_DOWN parent 1:100 classid 1:${8}1 htb rate $CLIENT_DOWN_RATE ceil $CLIENT_DOWN_CEIL

# PRIO 1 -> icmp traffic
$TC class add dev $DEV_P1_DOWN parent 1:${8}1 classid 1:${8}2 htb rate 33kbit ceil $CLIENT_DOWN_CEIL prio 1

# PRIO 2 -> udp, ssh
$TC class add dev $DEV_P1_DOWN parent 1:${8}1 classid 1:${8}3 htb rate 33kbit ceil $CLIENT_DOWN_CEIL prio 2

# PRIO 3 -> tcp sport 80
$TC class add dev $DEV_P1_DOWN parent 1:${8}1 classid 1:${8}4 htb rate 33kbit ceil $CLIENT_DOWN_CEIL prio 3

# PRIO 4 -> unclassified traffic
$TC class add dev $DEV_P1_DOWN parent 1:${8}1 classid 1:${8}5 htb rate 33kbit ceil $CLIENT_DOWN_CEIL prio 4

# icmp- icmp- 1
$TC filter add dev $DEV_P1_DOWN protocol ip parent 1:0 prio 1 u32 match ip dst $CLIENT_IP \
match ip protocol 1 0xff flowid 1:${8}2

# udp
$TC filter add dev $DEV_P1_DOWN protocol ip parent 1:0 prio 2 u32 match ip dst $CLIENT_IP \
match ip protocol 17 0xff flowid 1:${8}3
# ssh
$TC filter add dev $DEV_P1_DOWN protocol ip parent 1:0 prio 2 u32 match ip dst $CLIENT_IP \
match ip protocol 6 0xff match ip sport 22 0xffff flowid 1:${8}3
# WWW, sport 80
$TC filter add dev $DEV_P1_DOWN protocol ip parent 1:0 prio 3 u32 match ip dst $CLIENT_IP \
match ip protocol 6 0xff match ip sport 80 0xffff flowid 1:${8}4
# – ,
$TC filter add dev $DEV_P1_DOWN protocol ip parent 1:0 prio 4 u32 match ip dst $CLIENT_IP flowid 1:${8}5

# UPSTREAM
#####################

CLIENT_UP_RATE=$5
CLIENT_UP_CEIL=$6

###

$TC class add dev $DEV_P1_UP parent 1:100 classid 1:${8}1 htb rate $CLIENT_UP_RATE ceil $CLIENT_UP_CEIL
# PRIO 1 -> icmp traffic
$TC class add dev $DEV_P1_UP parent 1:${8}1 classid 1:${8}2 htb rate 1kbit ceil $CLIENT_UP_CEIL prio 1
# PRIO 2 -> udp, ssh
$TC class add dev $DEV_P1_UP parent 1:${8}1 classid 1:${8}3 htb rate 1kbit ceil $CLIENT_UP_CEIL prio 2
# PRIO 3 -> unclassified traffic
$TC class add dev $DEV_P1_UP parent 1:${8}1 classid 1:${8}4 htb rate 1kbit ceil $CLIENT_UP_CEIL prio 3
$TC filter add dev $DEV_P1_UP protocol ip parent 1:0 prio 1 u32 match ip src $CLIENT_IP \
match ip protocol 1 0xff flowid 1:${8}2
$TC filter add dev $DEV_P1_UP protocol ip parent 1:0 prio 2 u32 match ip src $CLIENT_IP \
match ip protocol 17 0xff flowid 1:${8}3
$TC filter add dev $DEV_P1_UP protocol ip parent 1:0 prio 2 u32 match ip src $CLIENT_IP \
match ip protocol 6 0xff match ip dport 22 0xffff flowid 1:${8}3
$TC filter add dev $DEV_P1_UP protocol ip parent 1:0 prio 3 u32 match ip src $CLIENT_IP flowid 1:${8}4

done < ./users

इन लिपियों को एक निर्देशिका में रखना होगा, भागो:

chmod +x ./rc.shape

और फिर

./rc.shape start

मैंने यातायात को सीमित करने के तरीकों में से एक का वर्णन किया। यातायात प्रतिबंधों के संदर्भ में टीसी उपयोगिता बहुत शक्तिशाली चीज है। मैं दस्तावेज़ को पढ़ने की सलाह देता हूं: इस मुद्दे के अधिक गहन अध्ययन के लिए LARTC-HOWTO।

लिनक्स पर इनबाउंड और आउटबाउंड ट्रैफिक को सीमित करें

More articles: