SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor

Ubuntu पर iptables और nftables में क्या अंतर है?

Ubuntu के आधुनिक वर्ज़न में iptables कमांड वास्तव में nftables रूल्स लिखती है। अपने सर्वर पर यह कैसे चेक करें और ufw व Docker के बीच होने वाले टकराव को कैसे समझें, जानें यहाँ।

Ubuntu पर iptables बनाम nftables: आपका सर्वर किसका उपयोग कर रहा है?

Ubuntu 20.10 और उसके बाद के वर्ज़न, जिसमें 22.04 LTS और उसके बाद के सभी LTS रिलीज़ शामिल हैं, में iptables कमांड एक फ्रंट-एंड है जो nftables रूल्स लिखता है। कर्नल में केवल एक पैकेट फिल्टर चलता है, जो nftables है, और दो यूजर-स्पेस कमांड इसे प्रोग्राम करते हैं। एक iptables -A INPUT लाइन अभी भी बिल्कुल वैसे ही काम करती है जैसे पहले करती थी, और इसके द्वारा बनाया गया रूल एक nftables रूल होता है जिसे nft प्रिंट कर सकता है।

Ubuntu 20.04 एक अपवाद है। इसका iptables 1.8.4 पैकेज legacy बैक-एंड को प्राथमिकता देने के लिए सेट किया गया था, और 20.04 के किसी भी अपडेट ने इसे नहीं बदला, इसलिए 20.04 पर iptables पुराने x_tables रूल्स लिखता है और iptables -V, (legacy) रिपोर्ट करता है। nftables बैक-एंड पर स्विच 20.10 पैकेज में आया था।

किसी भी निष्कर्ष पर पहुँचने से पहले अपने सर्वर पर इसकी पुष्टि करें।

iptables -V
sudo update-alternatives --display iptables
sudo nft list ruleset

Ubuntu 24.04 (अक्टूबर 2026 तक iptables 1.8.10) पर, iptables -V, iptables v1.8.10 (nf_tables) प्रिंट करता है। ब्रैकेट में दिया गया नाम बैक-एंड है। (nf_tables) का अर्थ है कि कमांड nftables से बात कर रही है। (legacy) का अर्थ है पुराना x_tables बैक-एंड, जिसे Ubuntu अभी भी iptables-legacy के रूप में शिप करता है और जिसे कर्नल एक पूरी तरह से अलग रूल्सेट के रूप में रखता है। update-alternatives उस विकल्प के पीछे के सिमलिंक (symlink) को प्रिंट करता है: link currently points to /usr/sbin/iptables-nft।

बिना किसी फायरवॉल कॉन्फ़िगरेशन वाले एक नए VPS पर, sudo nft list ruleset कुछ भी प्रिंट नहीं करता है। वह खाली आउटपुट आपका बेसलाइन है। पुराने तरीके से एक रूल जोड़ें और फिर से देखें।

sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT
sudo nft list ruleset
# Warning: table ip filter is managed by iptables-nft, do not touch!
table ip filter {
  chain INPUT {
    type filter hook input priority filter; policy accept;
    tcp dport 22 counter packets 0 bytes 0 accept
  }
  chain FORWARD {
    type filter hook forward priority filter; policy accept;
  }
  chain OUTPUT {
    type filter hook output priority filter; policy accept;
  }
}

आपका iptables रूल वास्तव में एक nftables रूल है। iptables-nft उन टेबल्स को मार्क करता है जिन्हें यह बनाता है और nft उस मार्क को देखने पर वह चेतावनी प्रिंट करता है, क्योंकि ऐसी टेबल को nft के साथ एडिट करने से एक ही रूल्स पर दो टूल्स का नियंत्रण हो जाता है। देखें कि एक कमांड ने क्या उत्पन्न किया: एक ऐसी टेबल जिसे आपने नाम नहीं दिया, और ऐसी चेन्स जिनके लिए आपने नहीं कहा था। यह पुराना मॉडल है, और nftables को सीधे लिखते समय यह सबसे पहली चीज है जो बदल जाती है।

क्या iptables -L आपसे छिपाता है

iptables -L केवल filter टेबल दिखाता है। NAT (network address translation) नियमों के लिए iptables -t nat -L की आवश्यकता होती है, और mangle नियमों के लिए -t mangle की। IPv6 एक अलग कमांड, ip6tables में रहता है, जिसमें हर नियम की अपनी अलग कॉपी होती है। इसलिए, एक सर्वर एक लिस्टिंग में साफ दिख सकता है, जबकि कोई ऐसी टेबल से आपके पैकेट ड्रॉप या रीराइट कर रही हो जिसे आपने कभी चेक ही नहीं किया।

sudo nft list ruleset एक ही आउटपुट में हर फैमिली, हर टेबल, हर चेन और हर नियम को प्रिंट करता है। जिस सर्वर को आपने खुद सेटअप नहीं किया है, उस पर यह कमांड यह देखने का सबसे तेज़ तरीका है कि वास्तव में क्या लोड है। नियम के हैंडल (rule handles) प्रिंट करने के लिए -a जोड़ें, जिसकी आवश्यकता आपको पूरी चेन के बजाय केवल एक नियम को हटाने के लिए पड़ती है।

यहाँ रहते हुए दो आदतें सुधारना फायदेमंद है। iptables -L एड्रेस और पोर्ट्स को नामों में बदलता है, इसलिए यदि किसी सर्वर का DNS resolver खराब है, तो यह कमांड हैंग हुआ लग सकता है: इसके बजाय iptables -nvL का उपयोग करें। और यह सुनिश्चित करें कि legacy back end खाली है, इसके लिए sudo iptables-legacy -nvL का उपयोग करें। यदि दोनों back ends में नियम मौजूद हैं, तो kernel दोनों का मूल्यांकन करता है, और कोई भी लिस्टिंग आपको पूरी स्थिति नहीं दिखाती है।

आपके द्वारा बनाई गई और इनहेरिट न की गई Tables और chains

nftables शून्य से शुरू होता है। जब तक आप कोई table नहीं बनाते, तब तक कोई filter table मौजूद नहीं होती, और filter शब्द केवल आपके द्वारा चुना गया एक नाम है। एक chain पैकेट को तभी देखती है जब आप उसे type, hook और priority देते हैं, जो उसे एक base chain बनाता है। इनके बिना, एक chain तक केवल स्पष्ट jump या goto के माध्यम से ही पहुँचा जा सकता है, इसलिए जब तक कोई उस पर jump नहीं करता, तब तक यह कोई संसाधन खर्च नहीं करती।

दूसरा बड़ा बदलाव inet family है। एक inet table IPv4 और IPv6 दोनों को एक ही rules में संभालती है, जिससे उस तरह की त्रुटियों का एक पूरा वर्ग समाप्त हो जाता है जहाँ एक port iptables में बंद होता है और ip6tables में पूरी तरह खुला रहता है। यह विसंगति इतनी आम है कि ufw boxes पर इसका अपना एक failure mode है।

यहाँ एक पूर्ण server ruleset दिया गया है। इसे /etc/nftables.conf में रखा जाता है।

#!/usr/sbin/nft -f
flush ruleset

table inet filter {
  set admin_ips {
    type ipv4_addr
    flags interval
    elements = { 203.0.113.5, 198.51.100.0/24 }
  }

  chain input {
    type filter hook input priority filter; policy drop;
    ct state established,related accept
    ct state invalid drop
    iif lo accept
    ip protocol icmp accept
    meta l4proto ipv6-icmp accept
    tcp dport 22 ip saddr @admin_ips counter accept
    tcp dport { 80, 443 } counter accept
  }

  chain forward {
    type filter hook forward priority filter; policy drop;
  }

  chain output {
    type filter hook output priority filter; policy accept;
  }
}

दूसरी पंक्ति को दो बार पढ़ें। flush ruleset बॉक्स पर मौजूद हर table को हटा देता है, जिसमें ufw और Docker द्वारा स्वयं के लिए बनाई गई tables भी शामिल हैं। इसे किसी live server पर चलाने से पहले आगे पढ़ना जारी रखें।

input chain का पहला नियम अधिकांश कार्य करता है। ct state established,related accept आपके द्वारा शुरू किए गए connections के उत्तरों को वापस आने देता है, इसलिए chain के बाकी हिस्सों को केवल नए connections के बारे में निर्णय लेना होता है। ct state invalid drop उन पैकेट्स को हटा देता है जो किसी ज्ञात connection या वैध शुरुआत से मेल नहीं खाते। उसके बाद सब कुछ एक स्पष्ट hole है, और policy drop बाकी को संभालता है।

फ़ाइल को लोड करने से पहले उसकी जाँच करें, और ऐसा करते समय एक दूसरा SSH session खुला रखें। policy drop और SSH नियम में एक typo आपको आपके अपने server से बाहर कर सकता है।

sudo nft -c -f /etc/nftables.conf
sudo nft -f /etc/nftables.conf
sudo nft list ruleset

nft -c -f फ़ाइल को पार्स करता है और कुछ भी लोड किए बिना त्रुटियों की रिपोर्ट करता है। एक सफल पार्स के बाद कोई आउटपुट नहीं दिखता है।

Sets लंबी rule lists की जगह लेते हैं

tcp dport { 80, 443 } एक anonymous set है: इसमें हर port के लिए अलग rule बनाने के बजाय एक rule और एक lookup का उपयोग होता है। admin_ips जैसा named set और भी बेहतर है, क्योंकि आप firewall चलते समय भी इसमें बदलाव कर सकते हैं।

sudo nft add element inet filter admin_ips { 203.0.113.9 }
sudo nft list set inet filter admin_ips
sudo nft delete element inet filter admin_ips { 203.0.113.9 }

इसमें न तो reload की जरूरत होती है और न ही rule renumbering की। चाहे set में 5 address हों या 50,000, match हमेशा एक ही lookup रहता है। flags interval वह flag है जो set को ranges और 198.51.100.0/24 जैसे CIDR (classless inter-domain routing) prefixes रखने की अनुमति देता है। इस flag के बिना set केवल single addresses ही स्वीकार करता है, और prefix load करने पर error आता है।

Sets अपने elements को खुद expire भी कर सकते हैं।

set banned {
  type ipv4_addr
  flags timeout
  timeout 1h
}

ip saddr @banned drop rule के साथ, हर element जुड़ने के एक घंटे बाद खुद हट जाता है। यही कारण है कि Ubuntu 24.04 पर fail2ban में nftables action एक address को ban करने के लिए rule नहीं, बल्कि set में एक element जोड़ता है। यदि ports आपके लिए नया विषय हैं, तो Linux पर port वास्तव में क्या है से शुरुआत करें।

migration के दौरान एक अंतर अक्सर लोगों को उलझा देता है। nftables तब तक packets की गिनती नहीं करता जब तक आप ऐसा करने के लिए न कहें। iptables -nvL हमेशा हर rule के लिए counters दिखाता है। nftables में केवल उन्हीं rules में numbers होते हैं जिनमें counter keyword हो, इसलिए जिन rules को आप बाद में debug करना चाहते हैं, उनमें counter जरूर लगाएँ।

Hooks और priorities यह कैसे तय करते हैं कि क्रम क्या होगा

एक base chain एक hook का नाम बताती है, जो packet path में वह बिंदु है जहाँ यह run होती है। prerouting routing निर्णय से पहले run होता है। input इस machine के लिए संबोधित packets के लिए run होता है। forward इसके माध्यम से route होने वाले packets के लिए run होता है। output local processes से आने वाले packets के लिए run होता है। postrouting सबसे अंत में run होता है, ठीक packet के बाहर निकलने से पहले।

Priority एक ही hook के भीतर chains को क्रमबद्ध करती है, जिसमें सबसे छोटी संख्या पहले आती है। nftables classic values को नाम देता है: raw का मान -300 है, mangle का मान -150 है, dstnat का मान -100 है, filter का मान 0 है, srcnat का मान 100 है। priority filter; लिखना priority 0; लिखने के समान ही है।

अब वह हिस्सा जो यह तय करता है कि क्या tools को मिलाना काम करेगा। एक hook पर registered हर base chain, priority के क्रम में run होती है। आपकी chain में accept किया गया packet समाप्त नहीं होता है: accept केवल उस chain को समाप्त करता है, और packet उसी hook पर अगली base chain तक आगे बढ़ता है। drop हर जगह अंतिम है और packet को तुरंत रोक देता है। इसलिए आपकी table में एक permissive rule ufw की table में drop को undo नहीं कर सकता, चाहे कोई भी पहले run हो, और आपका accept आपको बाद में run होने वाली chain से कोई सुरक्षा नहीं देता।

एक ही hook पर समान priority वाली दो base chains registration के क्रम में run होती हैं, जो इस बात पर निर्भर करता है कि कौन सी service पहले start हुई। वह क्रम reboot के बाद बदल सकता है। यदि आपको ufw के साथ अपनी table run करनी ही है, तो इसे एक अलग priority दें ताकि क्रम पहले से निर्धारित हो, न कि वह race condition पर निर्भर रहे।

रिवर्स NAT नियम लिखने की आवश्यकता क्यों नहीं है?

यह वह प्रश्न है जिसे लोग सबसे अधिक गलत समझते हैं, इसलिए यहाँ इसका सीधा उत्तर है। Connection tracking आपके लिए रिवर्स ट्रांसलेशन (reverse translation) लिख देता है। इसमें जोड़ने के लिए कोई दूसरा नियम नहीं होता।

एक nat table जो सामान्य VPS कार्य के दोनों हिस्सों को पूरा करती है, वह इस प्रकार दिखती है।

table inet nat {
  chain prerouting {
    type nat hook prerouting priority dstnat; policy accept;
    iifname "enp1s0" tcp dport 8080 dnat ip to 10.0.0.5:80
  }

  chain postrouting {
    type nat hook postrouting priority srcnat; policy accept;
    ip saddr 10.0.0.0/24 oifname "enp1s0" masquerade
  }
}

एक connection के केवल पहले packet का मूल्यांकन nat chain के विरुद्ध किया जाता है। जब कोई नियम मेल खाता है, तो kernel उस ट्रांसलेशन को connection tracking table में connection की entry के साथ संग्रहीत कर लेता है। बाद के प्रत्येक packet को, दोनों दिशाओं में, संग्रहीत entry से फिर से लिखा जाता है, और कोई भी नियम दोबारा नहीं पढ़ा जाता। conntrack टूल इंस्टॉल करें और एक लाइव entry देखें।

sudo apt install -y conntrack
sudo conntrack -L -p tcp
tcp 6 431999 ESTABLISHED src=198.51.100.20 dst=203.0.113.10 sport=54321 dport=8080 src=10.0.0.5 dst=198.51.100.20 sport=80 dport=54321 [ASSURED] mark=0 use=1

इसे दो tuples के रूप में पढ़ें। पहले चार fields वह connection हैं जैसा कि client ने इसे भेजा था, जिसे 203.0.113.10:8080, यानी आपके public address पर संबोधित किया गया था। दूसरे चार वह reply हैं जिसकी kernel अपेक्षा करता है, जो पहले से ही reversed और translated है, और 10.0.0.5:80, यानी वास्तविक backend से आ रहा है। वह दूसरा tuple ही रिवर्स नियम है। जब पहला packet मेल खाया था, तो kernel ने इसे लिख दिया था।

इसलिए वापसी की दिशा (return direction) के लिए कोई नियम न लिखें। यह मेल नहीं खा सकता, क्योंकि return packets एक स्थापित connection का हिस्सा होते हैं और कभी भी nat chain तक नहीं पहुँचते, और यदि किसी तरह यह मेल खा भी गया, तो आप उस packet को फिर से translate करेंगे जिसे kernel पहले ही ठीक कर चुका है।

rewrite कहाँ होना चाहिए, यह इसी तंत्र से तय होता है। Destination translation को prerouting में, routing निर्णय से पहले चलना चाहिए, क्योंकि routing को नया destination देखना होगा अन्यथा packet गलत जगह चला जाएगा। जो traffic box स्वयं उत्पन्न करता है, उसे भी इसी कारण से output hook में संभाला जाता है। Source translation, जिसमें source port rewrite भी शामिल है, को postrouting में, routing द्वारा outgoing interface चुने जाने के बाद चलना चाहिए। masquerade अपना address उस interface से लेता है, और interface तब तक ज्ञात नहीं होता जब तक routing न हो जाए।

यही कारण है कि इस तरह का नियम path के अंत में ही होना चाहिए और कहीं नहीं।

ip saddr 10.0.0.0/24 oifname "enp1s0" snat ip to 203.0.113.10:20000-30000

Port range source address के साथ-साथ source port को भी rewrite करती है, जो तब आवश्यक होता है जब कई internal clients एक ही public address साझा करते हैं और उनके source ports आपस में टकराते हैं। उस range में संबोधित एक reply आता है, conntrack इसे entry से मिलाता है, और packet डिलीवर होने से पहले मूल source port को वापस लगा दिया जाता है। फिर से, कोई दूसरा नियम नहीं।

एक व्यावहारिक परिणाम: NAT नियम बदलने से पहले से मौजूद connections पर कोई प्रभाव नहीं पड़ता, क्योंकि उनका ट्रांसलेशन पहले ही संग्रहीत हो चुका होता है। वे अपनी entries समाप्त होने तक पुराने व्यवहार को ही बनाए रखते हैं। sudo conntrack -D -p tcp --dport 8080 मेल खाने वाली entries को हटा देता है और sudo conntrack -F उन सभी को हटा देता है। NAT बॉक्स पर दूसरे वाले का उपयोग सावधानी से करें, क्योंकि वे संग्रहीत ट्रांसलेशन ही वर्तमान connections को जीवित रखते हैं, इसलिए उन्हें फ्लश करने से बॉक्स से गुजरने वाले सभी connections एक साथ टूट जाएंगे।

ufw और Docker दोनों अपने नियम स्वयं लिखते हैं

ufw, iptables का एक फ्रंट-एंड है, जो Ubuntu 20.10 और उसके बाद के वर्ज़न में nftables का फ्रंट-एंड है। इसलिए, एक ufw बॉक्स में ip filter टेबल होती है, जो ufw-before-input, ufw-user-input आदि जैसे चेन्स से भरी होती है, साथ ही उसी संरचना की एक ip6 filter कॉपी भी होती है। इसे sudo nft list ruleset | grep ufw के साथ देखें। ये चेन्स /etc/ufw की फाइलों से उत्पन्न होती हैं, और ufw reload उन्हें शुरू से फिर से लिखता है, यही कारण है कि ऊपर से जोड़ा गया हाथ से लिखा हुआ iptables नियम अगले रीलोड पर गायब हो जाता है। VPS के लिए ufw की बुनियादी बातें उस फाइल लेआउट को कवर करती हैं।

Docker फायरवॉल को स्वयं प्रोग्राम करता है और ufw से परामर्श नहीं करता है। -p 80:80 के साथ पोर्ट पब्लिश करने पर nat टेबल में एक DNAT नियम और फॉरवर्ड पाथ में एक एक्सेप्ट (accept) नियम लिखा जाता है, और ये दोनों ufw की यूजर चेन्स से पहले चलते हैं। इसका परिणाम हर किसी को हैरान कर देता है: ufw deny 80 लोड हो जाता है, और कंटेनर अभी भी इंटरनेट से एक्सेस किया जा सकता है। इसका समाधान उस DOCKER-USER चेन में है जिसे Docker आपके नियमों के लिए छोड़ देता है, और Docker कंटेनर ufw को क्यों अनदेखा करते हैं इस प्रक्रिया को विस्तार से समझाता है। sudo nft list ruleset | grep -i docker के साथ देखें कि आपके बॉक्स पर क्या चल रहा है।

अब ऊपर दिए गए कॉन्फ़िगरेशन से उस flush ruleset लाइन को फिर से पढ़ें। यह हर टेबल को हटा देता है, जिसमें वे टेबल्स भी शामिल हैं जिन्हें ये दो टूल्स मैनेज करते हैं। एक Docker होस्ट पर, पब्लिश किए गए पोर्ट तब तक काम करना बंद कर देते हैं जब तक कि sudo systemctl restart docker चेन्स को फिर से न बना ले। फायरवॉल को साफ करते समय अपनी खुद की सेवाओं को ऑफलाइन करने का यह एक लाइन वाला तरीका सबसे आम है।

Reboot के बाद भी सक्रिय रहने वाले नियम

दोनों में से कोई भी ruleset अपने आप persistent नहीं रहता है। शटडाउन के समय kernel सब कुछ भूल जाता है, और प्रत्येक पक्ष इसे एक अलग package के साथ हल करता है।

nftables के लिए, /etc/nftables.conf को nftables.service द्वारा पढ़ा जाता है। Ubuntu इस service को disabled रखता है, इसलिए उस पर भरोसा करने से पहले उसे जाँच लें।

systemctl is-enabled nftables
sudo nft -c -f /etc/nftables.conf
sudo systemctl enable --now nftables

iptables के लिए, package iptables-persistent है, जो netfilter-persistent को install करता है और /etc/iptables/rules.v4 तथा /etc/iptables/rules.v6 में save करता है।

sudo apt install -y iptables-persistent
sudo netfilter-persistent save

दोनों को एक साथ न चलाएं। दो फाइलें जो दोनों ही firewall को संभालने का दावा करती हैं, उनमें अंतर आ जाएगा, और जो अंत में load होगी वह इस तरह प्रभावी होगी कि कोई भी फाइल पढ़कर उसका अनुमान नहीं लगा पाएगा।

लाइव ruleset को dump करने में एक संबंधित खतरा है। sudo nft -s list ruleset > /etc/nftables.conf उस समय load किए गए हर नियम को capture कर लेता है, जिसमें ufw की tables और Docker की tables भी शामिल हैं। यदि आप इसे boot के समय restore करते हैं, तो आपको उन नियमों की एक frozen copy मिल जाएगी जिन्हें ये tools खुद बनाने की उम्मीद करते हैं, और फिर उनके start होने पर एक दूसरी copy बन जाएगी। केवल अपनी table को sudo nft -s list table inet filter के साथ dump करें। -s flag counters को हटा देता है, जिनकी config file में कोई आवश्यकता नहीं होती है।

क्या आपको अपने VPS पर firewall switch on करना चाहिए?

जब तक आपको ऐसी किसी चीज़ की आवश्यकता न हो जिसे ufw व्यक्त नहीं कर सकता, तब तक ufw को न छेड़ें। ufw सामान्य VPS कार्यों को कवर करता है: डिफ़ॉल्ट रूप से सभी को deny करना और कुछ चुनिंदा ports को open रखना। केवल दिखावे के लिए इसे हाथ से लिखे गए ruleset से बदलना आपको वही firewall देता है, लेकिन साथ ही रखरखाव का एक अतिरिक्त बोझ भी बढ़ाता है।

जब आपकी आवश्यकता ufw के मॉडल से बाहर हो, तब native तरीके अपनाएं: जैसे NAT और port forwarding, runtime पर अपडेट होने वाले sets, एक ही rule जो दोनों address families को कवर करे, या अपनी पसंद की chain priorities। ये वास्तविक कारण हैं, और ufw में इनमें से किसी को भी लागू करने का कोई तरीका नहीं है।

यदि आप native तरीका अपनाते हैं, तो पूरी तरह से अपनाएं। sudo ufw disable और sudo systemctl disable --now ufw चलाएं, sudo nft list ruleset के साथ पुष्टि करें कि इसकी tables हट गई हैं, और फिर अपनी खुद की file load करें। यदि कोई सर्वर ufw और हाथ से लिखी गई table दोनों को एक साथ चलाता है, तो traffic तो pass होता रहेगा, लेकिन वास्तविक policy दो rulesets का मिश्रण बन जाएगी। इनका मूल्यांकन service startup के क्रम पर निर्भर करेगा, और कोई भी व्यक्ति दोनों files को पढ़कर यह नहीं बता पाएगा कि सर्वर वास्तव में क्या कर रहा है।

मौजूदा iptables ruleset को माइग्रेट करना

iptables-translate एक नियम को convert करता है और उसका nftables प्रारूप print करता है। यह सर्वर पर कुछ भी नहीं बदलता है।

iptables-translate -A INPUT -p tcp --dport 22 -j ACCEPT
nft add rule ip filter INPUT tcp dport 22 counter accept

iptables-restore-translate -f /etc/iptables/rules.v4 पूरे saved ruleset के लिए यही काम करता है। इसके output को पहला ड्राफ्ट मानें। यह conversion यांत्रिक है, इसलिए आपको पुराने table और chain के नाम वापस मिलते हैं और IPv4 तथा IPv6 के लिए दो अलग-अलग rulesets मिलते हैं। आपको केवल anonymous sets मिलते हैं, जहाँ पुराने नियम में पहले से ही -m multiport का उपयोग किया गया था और port list को braces में वापस लाया जाता है, इसलिए कोई named sets नहीं होते जिन्हें आप runtime पर update कर सकें। कुछ iptables extensions का कोई nftables अनुवाद नहीं होता है, इसलिए output में उन नियमों को देखें जिन्हें यह convert नहीं कर सका और उन्हें हाथ से लिखें। इसे हाथ से एक inet table के रूप में फिर से लिखें, फिर इसे live सर्वर पर ले जाने से पहले nft -c -f के साथ जांचें।

इन उदाहरणों में दिए गए पते documentation ranges 203.0.113.0/24 और 198.51.100.0/24 से लिए गए हैं, और enp1s0 एक interface का नाम है। मेरे उदाहरणों को copy करने के बजाय अपने पते ip route show default और ip -br addr से लें, क्योंकि वर्तमान Ubuntu images में शायद ही किसी चीज़ को eth0 कहा जाता है।

FAQ

क्या Ubuntu पर iptables deprecated है?

यह command हट नहीं रही है और यह Ubuntu 24.04 पर काम करती है। बदलाव यह हुआ है कि इसके पीछे क्या चल रहा है: iptables एक front end है जो iptables-nft back end के माध्यम से nftables rules लिखता है। अपने सिस्टम की जाँच iptables -V से करें, जो 24.04 पर iptables v1.8.10 (nf_tables) प्रिंट करता है। पुराना x_tables back end अभी भी iptables-legacy के रूप में उपलब्ध है, और इसमें पूरी तरह से अलग ruleset होता है, इसलिए rules को किसी एक back end में ही रखें, दोनों में नहीं।

क्या मुझे वापसी के रास्ते पर NAT को undo करने के लिए दूसरे rule की आवश्यकता है?

नहीं। Connection tracking अनुवाद को तब store कर लेती है जब किसी connection का पहला packet nat rule से मेल खाता है, और बाद के दोनों दिशाओं के सभी packets को उस stored entry से rewrite किया जाता है। sudo conntrack -L इसे प्रति connection दो tuples के रूप में दिखाता है: मूल दिशा, और फिर पहले से reversed reply। वापसी की दिशा के लिए लिखा गया rule मदद नहीं कर सकता, क्योंकि वापसी वाले packets कभी भी nat chain तक नहीं पहुँचते हैं।

क्या मैं ufw और अपने स्वयं के nftables rules एक साथ चला सकता हूँ?

यह काम करता है, लेकिन आप मुसीबत मोल ले रहे हैं। प्रत्येक base chain एक hook पर चलती है, इसलिए live policy दोनों rulesets का संयोजन होती है, जो priority के आधार पर और समान priority होने पर उस आधार पर क्रमबद्ध होती है जो service पहले शुरू हुई। किसी भी एक में drop अंतिम होता है, और आपके ruleset में accept दूसरे को उसी packet को drop करने से नहीं रोकता है। किसी एक tool को चुनें। यदि वह nftables है, तो पहले ufw को disable करें और पुष्टि करें कि इसकी tables sudo nft list ruleset से हट गई हैं।

मैं Ubuntu पर reboot के बाद nftables rules को कैसे सुरक्षित रखूँ?

Ruleset को /etc/nftables.conf में रखें, इसे sudo nft -c -f /etc/nftables.conf से जाँचें, और फिर sudo systemctl enable --now nftables चलाएँ। यह service डिफ़ॉल्ट रूप से enabled नहीं होती है, इसलिए systemctl is-enabled nftables को एक बार चलाना उचित है। जब आप वह file generate करें, तो केवल अपनी table को sudo nft -s list table inet filter के साथ dump करें, क्योंकि एक पूर्ण list ruleset dump उन tables को भी capture कर लेता है जिन्हें ufw और Docker स्वयं manage करते हैं।

क्या यह लेख उपयोगी था?