इस पोस्ट में सब कुछ मेरी अपनी डेस्क पर चल रहे NetBox 4.7.2 पर चलाया गया, जिसमें एक असली एस्टेट लोड है: एक साइट, एक कैबिनेट, चौदह डिवाइस, केबल, पावर और एड्रेस के साथ, तीन कस्टमरों में बँटे हुए। हर स्क्रीनशॉट उसी इंस्टेंस का है, और हर एरर मैसेज वही है जो मुझे सच में मिला।
यह उसी क्रम में चलती है जिसमें आप इससे मिलेंगे। यह चीज़ क्या है, आपको यह क्यों चाहिए, वह fork जिसके बारे में आप खोजने के एक हफ़्ते के अंदर सुनेंगे, इसे खड़ा कैसे करें, इसे किस क्रम में भरना पड़ता है, और फिर आपको इससे वापस क्या मिलता है। कस्टमाइज़ेशन और एक्सटेंशन का काम आखिर में है, क्योंकि जब तक आपने उस चीज़ का आकार नहीं देखा जिसे आप बढ़ा रहे हैं, तब तक उसका कोई मतलब नहीं बनता।
NetBox क्या है
NetBox एक डेटाबेस है, जिसकी इस बारे में बहुत पक्की राय है कि नेटवर्क किन चीज़ों से बनता है, और उसके ऊपर एक वेब एप्लिकेशन। यह PostgreSQL पर चलने वाला एक Django एप्लिकेशन है, जून 2016 में DigitalOcean के रिलीज़ करने के बाद से Apache 2.0 के तहत open source है, और आज इस प्रोजेक्ट की देखरेख NetBox Labs वॉलंटियर मेंटेनरों की एक टीम के साथ करती है।12
इसके नीचे दस एप्लिकेशनों में फैले 149 मॉडल हैं, जिन तक 146 REST endpoints और एक GraphQL endpoint से पहुँचा जाता है। यह गिनती किसी फ़ीचर पेज से नहीं पढ़ी गई, बल्कि इसी पोस्ट के लिए बनाए गए इंस्टेंस से गिनी गई:
| एप्लिकेशन | मॉडल | एप्लिकेशन | मॉडल |
|---|---|---|---|
| dcim | 56 | virtualization | 7 |
| extras | 23 | tenancy | 6 |
| ipam | 18 | wireless | 3 |
| circuits | 11 | users | 7 |
| vpn | 10 | core | 8 |
इनमें से छप्पन DCIM हैं, यानी फ़िज़िकल लेयर: साइट, लोकेशन, रैक, डिवाइस टाइप, डिवाइस, और हर तरह का पोर्ट, बे और केबल टर्मिनेशन जो किसी डिवाइस में हो सकता है। अठारह IPAM हैं। बाकी में सर्किट, टनल और IKE पॉलिसी, वर्चुअल मशीन और क्लस्टर, वायरलेस लिंक, tenancy, और वह मशीनरी आती है जो पूरी चीज़ को बढ़ाने लायक बनाती है।
गिनती असली बात नहीं है। असली बात जोड़ हैं, और इसे देखने का सबसे तेज़ तरीका वह स्क्रीन है जिसके लिए NetBox सबसे ज़्यादा जाना जाता है।
कैबिनेट से शुरू कीजिए, क्योंकि यही वह स्क्रीन है जो इस चीज़ को बेचती है।

वह एलिवेशन डेटा से बनता है, अपलोड नहीं किया गया। हर डिवाइस वहाँ इसलिए है क्योंकि कोई रिकॉर्ड कहता है कि वह उन रैक यूनिटों में है, उस दिशा में मुँह किए, और रंग उस रोल से आते हैं जो आपने उसे दिया। जगह का इस्तेमाल 28.6% दिखता है क्योंकि NetBox ने उसे खुद निकाला। उस नंबर को कोई मेंटेन नहीं करता।
इससे दो बातें निकलती हैं जो तस्वीर से ज़्यादा कीमती हैं।
आप पूछ सकते हैं कि कौन-सी यूनिट खाली हैं, और ऐसा जवाब पा सकते हैं जिस पर काम किया जा सके। आप यूनिटों को उनमें कुछ लगने से पहले रिज़र्व भी कर सकते हैं, और यही फ़र्क है उस जगह को बेचने में जो आपके पास है और उस जगह को बेचने में जो आपको लगता है कि आपके पास है।
यह जानबूझकर क्या नहीं करेगा
जो प्रोडक्ट जानता है कि वह क्या नहीं है, वह उस प्रोडक्ट से कहीं ज़्यादा दुर्लभ है जो सब कुछ खराब तरीके से करता है, और NetBox का अपना डॉक्यूमेंटेशन इस पर साफ़-साफ़ बोलता है। यह नेटवर्क मॉनिटरिंग, DNS सर्विस, RADIUS, कॉन्फ़िगरेशन मैनेजमेंट या फ़ैसिलिटी मैनेजमेंट नहीं देता।1
इससे भी ज़रूरी बात, यह आपके नेटवर्क की चाही गई स्थिति रखता है, उसकी ऑपरेशनल स्थिति नहीं, और डॉक्यूमेंटेशन कहता है कि लाइव नेटवर्क स्टेट का ऑटोमेटेड इम्पोर्ट “strongly discouraged” है, क्योंकि हर रिकॉर्ड को पहले किसी इंसान को जाँचना चाहिए।1
बाकी सब इसी फ़ैसले पर टिका है, और यही वह फ़ैसला है जिससे लोग बहस करते हैं। बहस यह होती है: source of truth को तो सच होना चाहिए, तो नेटवर्क को discover करो और उसे लोड कर दो। जवाब यह है कि discover किया गया नेटवर्क आपको बताता है कि वहाँ क्या है, और वहाँ जो है उसमें वह हर गलती शामिल है जो किसी ने कभी की। 2021 में गलत VLAN में छोड़ा गया एक स्विच पोर्ट एक तथ्य है। वह एक इरादा नहीं है।
NetBox इरादा रखता है। आपकी मॉनिटरिंग असलियत रखती है। दिलचस्प नंबर इन दोनों का फ़र्क है, और एक ही इनपुट से फ़र्क नहीं निकाला जा सकता।
दूसरा सिद्धांत भी उतनी ही साफ़ भाषा में लिखा है: अगर एक तरफ़ अपेक्षाकृत आसान अस्सी प्रतिशत वाला हल हो और दूसरी तरफ़ कहीं ज़्यादा जटिल पूरा हल, तो आसान वाला चुनिए।1 आपको यह पहली बार तब महसूस होगा जब आप कुछ ऐसा मॉडल करना चाहेंगे जो यह मॉडल नहीं करता, और आखिर के पास कई सेक्शन इसी पर हैं कि उस दीवार से टकराने पर क्या करें।
| NetBox करता है | NetBox नहीं करता |
|---|---|
| रिकॉर्ड रखता है कि वहाँ क्या होना चाहिए | poll करता है कि वहाँ क्या है |
| किसी पोर्ट का इच्छित VLAN रखता है | बताता है कि पोर्ट डाउन है |
| बताता है कि कोई prefix किस कस्टमर का है | उसके लिए उन्हें बिल भेजता है |
| किसी डिवाइस का कॉन्फ़िगरेशन टेम्पलेट से रेंडर करता है | उसे डिवाइस पर पुश करता है |
| सर्किट, प्रोवाइडर और कमिट को ट्रैक करता है | सर्किट को मॉनिटर करता है |
| बताता है कि डिवाइस किस रैक में है, और किस U में | कैबिनेट खोलता है |
उस दाएँ कॉलम को उन टूल्स की सूची की तरह पढ़िए जिनकी आपको अब भी ज़रूरत है। उसे गलत पढ़ेंगे तो आप NetBox को उन सबमें बदलने की कोशिश करेंगे, और इसी तरह एक source of truth एक और ऐसा सिस्टम बन जाता है जिस पर कोई भरोसा नहीं करता।
आपको इसकी ज़रूरत क्यों है
किसी managed service provider से पूछिए कि किसी कस्टमर के नेटवर्क का आधिकारिक रिकॉर्ड कहाँ रहता है, और आपको एक जवाब मिलेगा। उनके दो इंजीनियरों से अलग-अलग पूछिए और आपको दो जवाब मिलेंगे।
एक किसी स्प्रेडशीट की ओर इशारा करेगा। एक किसी ऐसे डायग्राम की ओर जिसे आखिरी बार किसी ने 2023 में सेव किया था और जो अब कंपनी छोड़ चुका है। कोई और कहेगा कि फ़ायरवॉल कॉन्फ़िग ही डॉक्यूमेंटेशन है, जो कम से कम ईमानदार है, क्योंकि कॉन्फ़िग बताता है कि बॉक्स क्या कर रहा है। बस यह नहीं बताता कि क्यों, या किसने माँगा था, या उस बॉक्स के पीछे के चार कस्टमरों में से कौन उस नियम के पैसे दे रहा है।
नाकामी कभी वह दिन नहीं होती जब आप देखते हैं कि रिकॉर्ड गलत है। नाकामी वह दिन होती है जब किसी को उसकी ज़रूरत पड़ती है।
| मौका | आपको क्या दिखाना है | न दिखा पाने की कीमत |
|---|---|---|
| रिन्यूअल की बातचीत | मासिक चार्ज से क्या मिलता है, उसका मद-वार हिसाब | कॉम्पिटिटर का कोटेशन मद-वार है, क्योंकि उन्होंने जाकर गिना |
| कोई इंजीनियर नोटिस दे देता है | जो कुछ वह जानता था, सब लिखा हुआ | छह महीने तक पता लगाना, एक-एक टिकट करके |
| कोई कस्टमर छोड़कर जाता है | उनकी अपनी एस्टेट का विवरण | उसे जोड़ने में तीन हफ़्ते, और एक रेफ़रेंस जो वे ईमानदारी से देंगे |
| कोई ऑडिटर स्कोप का सवाल पूछता है | कौन-से सिस्टम पर्सनल डेटा रखते हैं, और वे फ़िज़िकली कहाँ हैं | रेगुलेटर को कुछ ऐसा बताया गया जो बाद में सच नहीं निकला |
| किसी माइग्रेशन की कीमत लगानी है | वहाँ असल में क्या है, उसकी गिनती | आप अंदाज़े पर बोली लगाते हैं और फ़र्क खुद भरते हैं |
इनमें से कुछ भी अनोखा नहीं है। यह हर मंगलवार की बात है।
इससे आपको जो मिलता है वह डॉक्यूमेंटेशन नहीं है। डॉक्यूमेंटेशन वह चीज़ है जिसे आप लिखते हैं और फिर मेंटेन करना बंद कर देते हैं। आपको मिलता है एक डेटाबेस जो विरोधाभास रखने से मना करता है, और ऐसे सवालों के जवाब देता है जो किसी ने पहले से पूछने की सोची भी नहीं थी। इस पोस्ट में आगे एक कैबिनेट है जो किट से 28.6 प्रतिशत भरी निकलती है और पावर से 90.7 प्रतिशत। उसे ढूँढने कोई नहीं निकला था। वह बस एक बार डिवाइस टाइप पर wattage डालने से सामने आ गई।
ईमानदार चेतावनी भी इसके साथ आती है, और आखिरी सेक्शन उसी के बारे में है। कोई रिकॉर्ड उतना ही कीमती है जितना उसे सही रखने में आपका खर्च होता है। लेकिन विकल्प है एक ऐसा बिज़नेस जो खुद का वर्णन नहीं कर सकता, और यह बात सबसे पहले अक्सर किसी कस्टमर को पता चलती है।
दूसरा वाला: Nautobot
खोज शुरू करने के करीब एक हफ़्ते के अंदर आप इससे टकराएँगे, इसलिए यह जानना फ़ायदेमंद है कि हुआ क्या था।
2021 में Network to Code ने NetBox को fork किया और नतीजे का नाम Nautobot रखा। कोई soft fork या डिस्ट्रिब्यूशन नहीं: एक hard fork जो पाँच साल से अलग रास्ते पर है। इसके अपने v1.0 रिलीज़ नोट्स इसे “a divergent fork of NetBox 2.10” कहते हैं, रिपॉज़िटरी 19 फ़रवरी 2021 को बनी और v1.0.0 26 अप्रैल 2021 को आया।3
उनके बताए कारण उनके अपने ब्लॉग पर हैं और मेरे शब्दों के बजाय उन्हीं के शब्दों में पढ़ने लायक हैं। तीन चीज़ों ने इसे आगे बढ़ाया। वे एंटरप्राइज़ सपोर्ट बेचना चाहते थे: “We need to offer high-touch support models with Service Level Agreements (SLAs) we can guarantee. We need flexibility to offer Long-term Support (LTS) for customers who can’t upgrade at the pace of a fast moving open source project.” वे चाहते थे कि source of truth डॉक्यूमेंटेशन परोसने के बजाय एक ऑटोमेशन प्लेटफ़ॉर्म के केंद्र में बैठे। और “there became a growing divergence in our vision about what a Source of Truth for networking should look like and how to get there”।4
उस पहले कारण के साथ उसकी तारीख जोड़नी ज़रूरी है, क्योंकि वह अब सच नहीं रहा। फ़रवरी 2021 में NetBox के पीछे कोई कंपनी नहीं थी जो आपको कुछ बेचती। NetBox Labs की स्थापना 2023 तक नहीं हुई थी, IBM द्वारा NS1 को खरीदने के बाद यह उससे अलग होकर बनी, और इसके सह-संस्थापक NetBox के अपने लीड मेंटेनर हैं।5
और यह कोई तीसरी पार्टी नहीं है जिसने किसी और के प्रोजेक्ट पर बिज़नेस खड़ा कर लिया। NetBox Labs ही NetBox की संरक्षक है: प्रोजेक्ट का अपना डॉक्यूमेंटेशन कहता है “the open source project is stewarded by NetBox Labs and a team of volunteer maintainers”।1 वे self-managed इंस्टॉल के लिए NetBox Enterprise बेचते हैं, NetBox Cloud के रूप में इसे आपके लिए होस्ट करते हैं, और 24/7 सपोर्ट देते हैं।6
तो “NetBox के लिए सपोर्ट खरीदा नहीं जा सकता” उस समय कहना ठीक था जब Network to Code ने fork किया, और अब कहना ठीक नहीं है। दोनों प्रोजेक्ट के पीछे एक कमर्शियल कंपनी है जो कॉन्ट्रैक्ट पर साइन करेगी, और NetBox के मामले में वह कंपनी वही है जो प्रोजेक्ट की देखरेख करती है।
जो लाइन ज़्यादातर लोग छोड़ देते हैं वह अगली है, और यही वजह है कि यह कोई गंदी कहानी नहीं है: “the NetBox project team suggested that we should consider forking.”
कोई fork इससे ज़्यादा सभ्य मुश्किल से होता है। दो समूह अलग-अलग चीज़ें चाहते थे, लंबे समय तक यह कहते रहे, और एक codebase पर लड़ने के बजाय अलग हो गए। दोनों हिस्से अब भी Apache 2.0 हैं। किसी ने ऐसा कुछ नहीं लिया जिसका उसे हक नहीं था।
यह fork असल में किस लिए था
Nautobot 1.0 के रिलीज़ नोट्स बताते हैं कि NetBox 2.10 के मुकाबले इसमें क्या जोड़ा गया, और यह सूची किसी भी ब्लॉग पोस्ट से बेहतर तरीके से बहस को समझाती है:3
| Nautobot ने 2021 में क्या जोड़ा | NetBox आज कहाँ है |
|---|---|
| GraphQL सपोर्ट | NetBox में है |
| डेटा सोर्स के रूप में Git इंटीग्रेशन | NetBox में है, synchronized data sources के रूप में |
| Single sign-on | NetBox में है |
| Secrets | NetBox में एक प्लगइन से है |
| Scripts और reports को Jobs में मिलाना | NetBox 4.7 में scripts को एक प्लगइन में ले जा रहा है |
| सभी मॉडलों पर custom fields | NetBox में custom fields का व्यापक सपोर्ट है |
| डेटा वैलिडेशन प्लगइन API | NetBox में custom validation rules हैं |
| डेटाबेस ऑब्जेक्ट के रूप में बदले जा सकने वाले स्टेटस | NetBox के स्टेटस अब भी एक Python choice set हैं |
| मॉडलों के बीच यूज़र-परिभाषित रिलेशनशिप | NetBox में इसका कोई समकक्ष नहीं |
| UUID primary keys | NetBox integer keys इस्तेमाल करता है |
| प्लगइन API में सुधार | NetBox का प्लगइन फ़्रेमवर्क तब से काफ़ी बढ़ा है |
ऊपर का ज़्यादातर आधा हिस्सा एक जैसा हो चुका है। Nautobot ने 2021 में जो कई चीज़ें दीं, वे बाद में NetBox में आईं, और जब दो प्रोजेक्ट सबके सामने एक ही समस्याएँ हल कर रहे हों तो आम तौर पर यही होता है।
नीचे की तीन चीज़ें एक जैसी नहीं हुईं, और वे दिखावटी नहीं बल्कि आर्किटेक्चर की हैं। मैंने 2021 के नोट्स पर भरोसा करने के बजाय आज दोनों codebase जाँचे।
Nautobot का Status एक डेटाबेस मॉडल है, जिसे उसके अपने सोर्स में “Model for database-backend enum choice objects” कहा गया है, यानी स्टेटस एक row है जिसे कोई UI में जोड़ सकता है। NetBox के स्टेटस एक Python choice set से आते हैं, इसीलिए नीचे वाला FIELD_CHOICES सेक्शन configuration.py एडिट करके और रीस्टार्ट करके एक स्टेटस जोड़ता है। Nautobot में Relationship और RelationshipAssociation मॉडल हैं, तो आप बिना कोड लिखे दो मौजूदा ऑब्जेक्ट टाइप के बीच रिलेशनशिप परिभाषित कर सकते हैं। NetBox का इस समस्या का जवाब एक प्लगइन है, जिसे नीचे सेक्शनों की एक पूरी कड़ी मिली है। और Nautobot की primary keys UUID हैं, जबकि NetBox की integers।
उन्होंने वह काम भी किया जिसके लिए उन्होंने fork किया था। आज की तारीख में Nautobot एक ही दिन 3.2.x और 2.4.x रिलीज़ कर रहा है, जो मौजूदा वर्शन के साथ चलती एक असली long-term मेंटेनेंस लाइन है, और यह तीन बताए गए कारणों में से एक था।
कौन-सा चुनें
पहले ईमानदार नंबर। NetBox के 21,625 stars और 3,133 forks हैं; Nautobot के 1,617 और 422।7 दोनों पर पिछले दो दिनों के अंदर push हुआ है, दोनों Apache 2.0 हैं, और दोनों के पीछे अब एक कमर्शियल कंपनी है जो सपोर्ट और होस्टिंग बेचती है।
यह अंतर क्वालिटी पर फ़ैसला नहीं है। यह पाँच साल की बढ़त को दिखाता है, और इस बात को कि source of truth ढूँढने वाले ज़्यादातर लोग पहले NetBox पाते हैं। लेकिन यह उस चीज़ का फ़ैसला ज़रूर करता है जो आम तौर पर फ़ीचर्स से ज़्यादा मायने रखती है: आप जो चुनेंगे उसके लिए आपको कितने प्लगइन, इंटीग्रेशन, Ansible मॉड्यूल, फ़ोरम के जवाब और सहकर्मी मिलेंगे।
तो: अगर आपको एक इन्वेंटरी और ऐसा source of truth चाहिए जिसे दूसरे सिस्टम पढ़ें, और आपको सबसे बड़ा इकोसिस्टम और सबसे आसान हायरिंग चाहिए, तो जवाब NetBox है, और इस पोस्ट का बाकी हिस्सा उसी के बारे में है। अगर source of truth चाहने की आपकी वजह खास तौर पर उससे ऑटोमेशन चलाना है, या आप चाहते हैं कि स्टेटस और रिलेशनशिप कोई कॉन्फ़िगरेशन फ़ाइल और रीस्टार्ट नहीं बल्कि आपकी टीम परिभाषित करे, तो फ़ैसला करने से पहले Nautobot को ठीक से देखिए।
किसी को भी आपको इनमें से कोई एक सिर्फ़ सपोर्ट के नाम पर बेचने मत दीजिए। अब दोनों तरफ़ यह मौजूद है, और जो अंतर पाँच साल बाद भी रहेंगे वे ऊपर की टेबल वाले हैं।
जो आपको नहीं करना चाहिए वह है किसी एक को इसलिए चुनना क्योंकि किसी ने आपसे कहा कि दूसरा मर चुका है। दोनों में से कोई नहीं मरा, और दोनों इसी हफ़्ते रिलीज़ निकाल रहे थे।
इसे चालू करना
दो रास्ते, और इस पोस्ट के लिए मैंने दोनों चलाए। अगर आपको यह बीस मिनट में चलता हुआ चाहिए तो कंटेनर, अगर इस पर बोझ टिकने वाला है तो होस्ट पर पैकेज।
कंटेनर स्टैक
कम्युनिटी netbox-docker मेंटेन करती है, जो जल्दी वाला जवाब है:8
git clone -b release https://github.com/netbox-community/netbox-docker.git
cd netbox-docker
tee docker-compose.override.yml <<'EOF'
services:
netbox:
ports:
- 8000:8080
EOF
docker compose pull
docker compose up
इससे आपको एप्लिकेशन, PostgreSQL, Redis और एक बैकग्राउंड वर्कर मिलते हैं, आपस में जुड़े हुए। मैंने हिस्से देखने के लिए यही चीज़ podman के तहत हाथ से बनाई, और हिस्से जानने लायक हैं क्योंकि उनमें से दो लोगों को पकड़ लेते हैं:
| कंटेनर | क्या करता है | अगर आप इसे छोड़ दें |
|---|---|---|
netbox | gunicorn के पीछे Django एप्लिकेशन | कुछ नहीं चलता |
postgres | डेटाबेस, 15 या उसके बाद का | कुछ नहीं चलता |
redis / valkey | दो डेटाबेस: एक टास्क के लिए, एक कैशिंग के लिए | कुछ नहीं चलता |
netbox-worker | rqworker, जो टास्क क्यू खाली करता है | webhooks कभी फ़ायर नहीं होते, बैकग्राउंड जॉब कभी नहीं चलते, और कुछ भी आपको चेतावनी नहीं देता |
netbox-housekeeping | समय-समय पर होने वाली सफ़ाई | change log रिकॉर्ड कभी expire नहीं होते |
असली बात वह चौथी row है। वर्कर के बिना सब कुछ ठीक दिखता है। Event rules क्यू में लगते हैं और वहीं पड़े रहते हैं।
पहली बार चलाने पर दो चीज़ों ने मुझे काटा, और दोनों में से कोई भी ऐसे एरर मैसेज में नहीं है जिसे आप खोजें।
पहला migration बहुत समय लेता है। एक मिनट नहीं। इस मशीन पर कई मिनट लगे, क्योंकि NetBox 4.7 django-mptt की जगह PostgreSQL ltree लाता है और रास्ते में हर hierarchical टेबल दोबारा बनाता है। कंटेनर बस वहाँ बैठा migrations लगाता रहता है। उसे छेड़िए मत।
API_TOKEN_PEPPERS के बिना आप v2 API token नहीं बना सकते, और इसका इकलौता संकेत लॉग में एक चेतावनी है:
UserWarning: API_TOKEN_PEPPERS is not defined. v2 API tokens cannot be used.
कम से कम एक सेट कीजिए, कम से कम पचास कैरेक्टर का, इससे पहले कि आप यह ढूँढने निकलें कि API आपको क्यों ठुकरा रहा है।
होस्ट पर, पैकेजों से
डॉक्यूमेंटेड रास्ता Ubuntu 24.04 पर टेस्ट किया गया है। मैंने इसे एक साफ़ मशीन पर शुरू से आखिर तक चलाया, और नतीजा यह रहा:
| कंपोनेंट | 24.04 ने मुझे क्या दिया | NetBox 4.7 को क्या चाहिए |
|---|---|---|
| PostgreSQL | 16.15 | 15 या उसके बाद का |
| Redis | 7.0.15 | 6.0 या उसके बाद का |
| Python | 3.12.3 | 3.12, 3.13 या 3.14 |
| Django | 6.1.1 | NetBox के साथ आता है |
| NetBox | v4.7.2 |
ये न्यूनतम ज़रूरतें NetBox की अपनी हैं, और 4.7 ने PostgreSQL और Redis दोनों की निचली सीमा बढ़ा दी।9
पूरा काम पाँच स्टेप का है।
# 1. the services
sudo apt install -y postgresql redis-server
sudo -u postgres psql -c "CREATE DATABASE netbox;"
sudo -u postgres psql -c "CREATE USER netbox WITH PASSWORD 'something-you-generated';"
sudo -u postgres psql -c "ALTER DATABASE netbox OWNER TO netbox;"
sudo -u postgres psql -d netbox -c "GRANT CREATE ON SCHEMA public TO netbox;"
# 2. the build dependencies
sudo apt install -y python3 python3-pip python3-venv python3-dev build-essential libxml2-dev libxslt1-dev libffi-dev libpq-dev libssl-dev zlib1g-dev git
# 3. the application, at a release tag rather than at main
sudo mkdir -p /opt/netbox && cd /opt/netbox
sudo git clone https://github.com/netbox-community/netbox.git .
sudo git checkout v4.7.2
sudo adduser --system --group netbox
sudo chown -R netbox /opt/netbox/netbox/media/ /opt/netbox/netbox/scripts/ /opt/netbox/netbox/reports/
# 4. the configuration: five values, no more
cd /opt/netbox/netbox/netbox/
sudo cp configuration_example.py configuration.py
python3 /opt/netbox/netbox/generate_secret_key.py # run it twice
sudo $EDITOR configuration.py
# 5. let the upgrade script do the rest
sudo /opt/netbox/upgrade.sh
वे पाँच वैल्यू हैं ALLOWED_HOSTS, DATABASES, REDIS, SECRET_KEY और API_TOKEN_PEPPERS। आखिरी दो को अलग-अलग जनरेट कीजिए और एक को दूसरे के लिए दोबारा इस्तेमाल मत कीजिए। इसलिए key generator दो बार चलाइए और नतीजे अलग-अलग लाइनों में पेस्ट कीजिए।
upgrade.sh वर्चुअल एनवायरनमेंट बनाता है, हर Python dependency इंस्टॉल करता है, migrations चलाता है, ऑफ़लाइन इस्तेमाल के लिए डॉक्यूमेंटेशन बनाता है और static फ़ाइलें इकट्ठा करता है। किसी नई मशीन पर खत्म होने पर यह एक चेतावनी छापता है जो डरावनी दिखती है पर है नहीं:
WARNING: No existing virtual environment was detected. A new one has
been created. Update your systemd service files to reflect the new
Python and gunicorn executables. (If this is a new installation,
this warning can be ignored.)
फिर एक superuser, और यह चल पड़ता है:
source /opt/netbox/venv/bin/activate
cd /opt/netbox/netbox && python3 manage.py createsuperuser
किसी भी असली काम के लिए इसके आगे runserver नहीं, gunicorn लगाइए। कॉन्फ़िगरेशन और unit फ़ाइलें पहले से रिपॉज़िटरी में हैं, और यही बात जानने लायक है क्योंकि लोग अपनी खुद की लिख बैठते हैं:
sudo cp /opt/netbox/contrib/gunicorn.py /opt/netbox/gunicorn.py
sudo cp -v /opt/netbox/contrib/*.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable --now netbox netbox-rq
netbox.service gunicorn को 127.0.0.1:8001 पर चलाता है, netbox-rq.service वर्कर चलाता है, और TLS टर्मिनेट करने और /static सर्व करने के लिए आगे nginx या Apache लगता है। दो सर्विस, और दूसरी वही वर्कर है जो कंटेनर स्टैक को चाहिए।
इसे किस क्रम में भरना पड़ता है
नया NetBox राय रखने वाला एक खाली डेटाबेस है, और उसके साथ पहला घंटा आम तौर पर यह पता लगाने में जाता है कि वे राय क्या हैं। आप एक डिवाइस जोड़ने जाते हैं, और यह आपको जोड़ने नहीं देता।

वे लाल तारांकन ही पूरा सबक हैं। NetBox किसी चीज़ को तब तक रिकॉर्ड नहीं करेगा जब तक वे चीज़ें मौजूद न हों जिन पर वह टिकी है, और यह अड़ियलपन नहीं है: बिना टाइप वाला डिवाइस एक ऐसी row है जो उनमें से किसी भी सवाल का जवाब नहीं दे सकती जिनके लिए डिवाइस होता है।
तो अंदाज़ा लगाने के बजाय मैंने मॉडल से पूछा कि कौन-सी foreign keys सच में अनिवार्य हैं, और फिर API से हर नियम तोड़ने की कोशिश की यह देखने के लिए कि क्या लौटता है।
POST /api/dcim/device-types/ no manufacturer
{"manufacturer": ["This field is required."]}
POST /api/dcim/devices/ no device type
{"device_type": ["This field is required."]}
POST /api/dcim/interfaces/ no device
{"device": ["This field is required."]}
POST /api/ipam/aggregates/ no RIR
{"rir": ["This field is required."]}
POST /api/circuits/circuits/ no provider, no type
{"provider": ["This field is required."], "type": ["This field is required."]}
POST /api/virtualization/virtual-machines/ nothing at all
{"__all__": ["A virtual machine must be assigned to a site, cluster, or device."]}
हर एक ने मना किया, और ठीक-ठीक बताया कि कौन-सी चीज़ गायब है। यही जानकारी पहले से ज़रूरी चीज़ों की सूची के रूप में:
| बनाने के लिए | पहले ज़रूरी | वैकल्पिक, पर आप इसे पहले चाहेंगे |
|---|---|---|
| Tenant | कुछ नहीं | एक Tenant group |
| Region, Site group | कुछ नहीं | उसी तरह का एक parent, ये nest होते हैं |
| Site | कुछ नहीं | एक Region, एक Site group, एक Tenant |
| Location | एक Site | एक parent Location, एक Tenant |
| Rack type | एक Manufacturer | |
| Rack | एक Site | एक Location, Rack group, Rack role, Rack type, Tenant |
| Device type | एक Manufacturer | |
| Device role | कुछ नहीं | एक parent Device role, ये nest होते हैं |
| Device | एक Device role, एक Device type, एक Site | एक Rack और पोज़िशन, एक Platform, एक Tenant |
| Interface, और हर दूसरा कंपोनेंट | एक Device | |
| Cable | टर्मिनेट करने के लिए दो चीज़ें | एक Tenant |
| Aggregate | एक RIR | एक Tenant |
| VLAN | कुछ नहीं | एक VLAN group, एक Role, एक Tenant |
| Prefix | कुछ नहीं | एक Site, एक VLAN, एक Role, एक VRF, एक Tenant |
| IP address | कुछ नहीं | असाइन करने के लिए एक Interface, एक Tenant |
| Circuit | एक Provider और एक Circuit type | एक Tenant |
| Circuit termination | एक Circuit | उतरने के लिए एक Site |
| Cluster | एक Cluster type | एक Cluster group, एक Site, एक Tenant |
| Virtual machine | एक Site, एक Cluster या एक Device | एक Platform, एक Tenant |
| VM interface | एक Virtual machine |
दूसरा कॉलम वह है जो आपको महँगा पड़ता है। Prefixes, IP addresses, VLANs और tenants को कुछ भी नहीं चाहिए, तो पहले दिन आपको उन्हें किसी भी क्रम में बनाने से कोई नहीं रोकता। वे किसी काम के हैं या नहीं, यह अलग सवाल है, क्योंकि जिस एड्रेस के पीछे कोई इंटरफ़ेस नहीं वह सूची की एक row है, और जिस डिवाइस का कोई tenant नहीं उसे आप बाद में फिर से एडिट करेंगे।
असल में किस क्रम में काम करें
इससे एक क्रम निकलता है। इसके हिसाब से नीचे चलिए और कुछ भी आपको कभी मना नहीं करेगा।
पहले, वे चीज़ें जिन पर बाकी सब टिका है। इनमें से कुछ भी रोमांचक नहीं है और इन्हें गलत करना सस्ता पड़ता है।
- Tenant groups, फिर tenants। इन्हें बाकी सबसे पहले कीजिए। अट्ठाईस मॉडल tenant लेते हैं, जिनमें Site, Location और Rack भी हैं, तो अगर कस्टमर अभी मौजूद नहीं हैं तो आप उन्हें चलते-चलते नहीं लगा सकते और बाद में bulk-edit करते रहेंगे।
- Regions और site groups। दोनों वैकल्पिक, दोनों अपने अंदर nest होते हैं, और एक-दूसरे से स्वतंत्र हैं। Regions भूगोल के लिए हैं, site groups काम के लिए, और आप एक, दोनों या कोई भी नहीं इस्तेमाल कर सकते हैं।
- Sites। लगभग हर चीज़ की जड़। Site को कुछ नहीं चाहिए, इसीलिए यह पहली चीज़ है जो आप सच में बना सकते हैं।
- Locations। इन्हें एक site चाहिए, और ये nest होती हैं, तो rows वाला hall जिसमें pods हैं, तीन स्तर गहरा एक ही मॉडल है।
- Rack roles और rack groups। दोनों वैकल्पिक। Rack groups फ़्लैट होते हैं और locations के साथ दूसरी धुरी की तरह बैठते हैं, जो rows और pods के लिए काम आता है।
- Manufacturers, फिर rack types। Rack type को एक manufacturer चाहिए। अगर आप कैबिनेट खुद मॉडल नहीं कर रहे तो rack types छोड़ दीजिए।
- Racks। इन्हें एक site चाहिए। अगर आप इसे एक location भी देते हैं, तो वह location उसी site की होनी चाहिए, और NetBox यह जाँचता है।
फिर हार्डवेयर कैटलॉग, हार्डवेयर नहीं। एक भी डिवाइस जोड़ने से पहले आपको manufacturers, device types, device roles और, व्यवहार में, platforms चाहिए।
- Manufacturers। स्टेप 6 से आपके पास कुछ पहले से हो सकते हैं, क्योंकि rack types को भी इनकी ज़रूरत है। Module types को भी।
- Device types, हर एक को एक manufacturer चाहिए।
- Device roles, जो nest होते हैं, और platforms।
यही वह स्टेप है जिसे लोग छोड़ देते हैं, और यही तय करता है कि बाकी काम में कितनी टाइपिंग लगेगी। Device type अपने interfaces, ports और bays को टेम्पलेट के रूप में साथ रखता है, तो उससे बनाया गया हर डिवाइस सही कंपोनेंट्स के साथ पहले से तैयार आता है। टाइप एक बार सही कर लीजिए, और उनमें से चालीस रैक करना बस चालीस नाम हैं।
उस सूची में Platform अलग है, क्योंकि डिवाइस को सख्ती से इसकी ज़रूरत नहीं। फिर भी इसे अभी कर लीजिए। बाद में config template और NAPALM ड्राइवर यही साथ रखता है, और पूरी एस्टेट पर वापस जाकर इसे सेट करना वही शाम खा जाएगा जो आप tenants पर लगाते।
फिर खुद किट।
- Devices। Role, type और site तीनों ज़रूरी हैं। Rack और position वैकल्पिक हैं, और अगर आप इन्हें देते हैं तो इन्हें site से मेल खाना चाहिए।
- Components, अगर device type ने इन्हें पहले से नहीं दिया।
- Cables, कंपोनेंट्स के बीच।
फिर एड्रेसिंग, क्योंकि एड्रेस को रहने के लिए एक इंटरफ़ेस चाहिए और इंटरफ़ेस स्टेप 12 के बाद ही मौजूद होता है।
- RIRs, फिर aggregates।
- Prefix और VLAN roles, VRFs, VLAN groups फिर VLANs।
- Prefixes, फिर अलग-अलग IP addresses।
फिर कमर्शियल लेयर।
- Providers, provider accounts और circuit types।
- Circuits, फिर उन्हें sites पर terminate कीजिए।
और वर्चुअल एस्टेट, जो फ़िज़िकल वाली की नकल है।
- Cluster types और cluster groups, फिर clusters।
- Virtual machines, जिन्हें एक site, एक cluster या एक device चाहिए, फिर उनके interfaces।
स्टेप 1 से 10 एक दोपहर का काम है और एडमिन जैसे लगते हैं। इनमें कुछ भी चमकदार नहीं है। यही वह दोपहर भी है जो तय करती है कि स्टेप 11 एक सुबह लेगा या एक पखवाड़ा।
वे नियम जो बाद में काटते हैं
ज़रूरी फ़ील्ड्स आसान आधा हिस्सा हैं, क्योंकि वे तुरंत फ़ेल होते हैं और बताते हैं क्यों। जो लोगों को पकड़ते हैं वे consistency के नियम हैं, जो तभी चलते हैं जब आपके पास खुद का विरोध करने लायक डेटा हो जाता है:
device at Leeds, put in a Manchester rack
{"rack": ["Rack MCR1-A07 (A07) does not belong to site Leeds Edge."]}
device at Leeds, in a Manchester location
{"location": ["Location Hall 2 does not belong to site Leeds Edge."]}
rack at Leeds, in a Manchester location
{"__all__": ["Assigned location must belong to parent site (Leeds Edge)."]}
a second device in a unit that is already taken
{"position": ["U39.0 is already occupied or does not have sufficient
space to accommodate this device type: MX204 (1.0U)"]}
अगर कोई पूछे कि यह सब झंझट क्यों, तो मैं उस आखिरी वाले की ओर इशारा करूँगा। NetBox जानता है कि डिवाइस 1U है, जानता है कि कैबिनेट में क्या है, और आपको एक ही जगह में दो चीज़ें रिकॉर्ड नहीं करने देगा। आपकी स्प्रेडशीट आपको पूरी दोपहर यह करने देगी और एक शब्द नहीं बोलेगी, और आपको तब पता चलेगा जब कोई हाथ में बॉक्स लिए hall में खड़ा होगा।
इनमें से कोई भी कॉन्फ़िगर नहीं किया जा सकता और किसी को किया भी नहीं जाना चाहिए। यही एक रिकॉर्ड और एक ख्वाहिश के बीच का फ़र्क है।
इस्तेमाल: हर स्क्रीन आपको क्या देती है
एस्टेट लोड होने के बाद, यह रहा जो आपको असल में इससे वापस मिलता है। नीचे सब कुछ वही इंस्टेंस है: एक कैबिनेट, चौदह डिवाइस, तीन कस्टमरों में केबल और एड्रेस के साथ।
डिवाइस अपने कंपोनेंट्स ही है
उन हाइपरवाइज़रों में से किसी एक में क्लिक कीजिए, और दिलचस्प टैब summary नहीं, interfaces है।

एक row आर-पार पढ़िए। इंटरफ़ेस, उसकी स्पीड, आपने उसके बारे में क्या लिखा, उस पर एड्रेस, केबल पर लेबल, और दूसरे सिरे का पोर्ट। यह एक query है, और यही उस सवाल का जवाब है जो हर कोई असल में पूछता है: “यह किसमें लगा है”।
देखिए एड्रेस कहाँ बैठा है। यह eno1 पर है, सर्वर पर नहीं। यह तब तक बाल की खाल लगता है जब तक आपके पास एक ऐसा बॉक्स न हो जिसमें एक मैनेजमेंट इंटरफ़ेस, दो डेटा इंटरफ़ेस और एक loopback हो, और कोई पूछे कि उसकी ओर से कौन-सा एड्रेस जवाब देता है। जो मॉडल एड्रेस को डिवाइस पर टाँगता है वह आपको नहीं बता सकता। यह बता सकता है, और यह एक इंटरफ़ेस पर चार एड्रेस वाला बिल्कुल आम मामला भी संभाल सकता है।
केबल के पीछे चलिए
केबल कंपोनेंट्स पर टर्मिनेट होती हैं, डिवाइसों पर नहीं। एक सिरे पर इंटरफ़ेस, दूसरे पर इंटरफ़ेस, या एक front port, एक rear port, एक power outlet, एक circuit termination। पूरा फ़ीचर इसी बारीकी पर टिका है, और इसीलिए ऊपर की इंटरफ़ेस सूची बिना बताए अपने कॉलम में दूसरा सिरा छाप सकी।
केबल को डिवाइस से डिवाइस मॉडल कीजिए तो आपने एक तस्वीर बनाई है। उसे पोर्ट्स पर टर्मिनेट कीजिए तो NetBox उस पर चल सकता है।

यहाँ एक हॉप है, क्योंकि यह direct attach केबल है। बीच में पैच पैनल रखिए और यह उन पर चलता है, पैनल दर पैनल, और बताता है कि तीन कैबिनेटों से होकर जाने वाले रन के दूसरे सिरे पर क्या है। वरना इस काम में एक टॉर्च लगती है और कोई जो tone probe का दूसरा सिरा पकड़े खड़ा हो।
ट्रेस हर सिरे की पूरी लोकेशन भी छापता है। साइट, hall, कैबिनेट, face, रैक यूनिट। अगर आप कभी किसी कॉल पर किसी remote hands इंजीनियर को यह समझाने में लगे रहे हैं कि किस बॉक्स को देखना है, तो उस लाइन की पूरी कीमत वहीं है।
एड्रेस, एक टैब की तरह नहीं बल्कि एक ट्री की तरह
IPAM वह आधा हिस्सा है जिसके लिए लोग आते हैं।

इंडेंटेशन खुद एड्रेसों से निकाला जाता है। आप NetBox को नहीं बताते कि 10.20.20.0/24 10.20.0.0/16 के अंदर है, वह खुद समझ लेता है, और अगले साल जब कोई उसके बीच में एक /26 जोड़ेगा तब भी समझता रहेगा।
हर row में वे चीज़ें हैं जिनसे आप असल में फ़िल्टर करते हैं: वह किस VLAN से मैप होता है, role, और वह किस कस्टमर का है। इस्तेमाल भी गिना जाता है।
किसी एक को खोलिए और आपको उसके अंदर के एड्रेस मिलते हैं, और खाली जगहें भी।

वे हरी rows खाली जगह हैं, इस्तेमाल हुई जगह के साथ ही दिखाई गई। एक API कॉल है जो आपको किसी prefix से अगला खाली एड्रेस दे देती है, और IPAM ऑटोमेशन का यही एक टुकड़ा है जो तुरंत अपनी कीमत वसूल लेता है, क्योंकि वरना लोग यही काम स्प्रेडशीट पर आँखें गड़ाकर और उम्मीद करके करते हैं।
एक इंटरफ़ेस जितने चाहें उतने एड्रेस ले सकता है, दोनों फ़ैमिली के, और आप हर फ़ैमिली का एक डिवाइस का primary चुनते हैं।

एक पोर्ट पर दो IPv4 और दो IPv6, जो एक आम मंगलवार है और जिसे डिवाइस-केंद्रित मॉडल बिल्कुल भी व्यक्त नहीं कर सकता।
एड्रेस उस नेटवर्क के मास्क के साथ डालिए जिस पर वे हैं, /32 के रूप में नहीं। NetBox 10.20.20.11/32 स्वीकार कर लेगा और उसे सही prefix के नीचे रख देगा, क्योंकि containment होस्ट एड्रेस से निकाला जाता है। जो वह नहीं करेगा वह है बाद में आपके फ़ैसले पर सवाल उठाना: मास्क ठीक वैसे ही स्टोर होता है जैसा टाइप किया गया और जो भी उसे पढ़े उसे वैसा ही लौटाया जाता है, तो LAN एड्रेस पर /32 डिवाइस कॉन्फ़िगरेशन में /32 ही रेंडर करता है। यह आज फ़ॉर्म में नहीं, तीन महीने बाद किसी config template में काटता है।
एक इंस्टॉल, तीन कस्टमर
NetBox के ज़्यादातर ऑब्जेक्ट किसी tenant को असाइन किए जा सकते हैं। कोई एंटरप्राइज़ इसे बिज़नेस यूनिट्स के लिए इस्तेमाल करता है। अगर आप managed services बेचते हैं, तो आप हर कस्टमर के लिए एक बनाते हैं।

दाईं ओर का वह पैनल “इस कस्टमर के पास क्या है” का जवाब है, और उसने खुद को खुद जोड़ा। कोई रिपोर्ट नहीं, कोई स्प्रेडशीट नहीं, उस इंजीनियर से पूछना नहीं जिसने इसे बनाया।
tenancy का मतलब क्या है, इस पर सावधान रहना ज़रूरी है, क्योंकि पहले दिन इसे गलत करने का मतलब बाद में एक साल तक उधेड़ना है। Tenant का मतलब है कि ऑब्जेक्ट उस कस्टमर के लिए समर्पित है। जो राउटर सिर्फ़ उन्हें सर्व करता है उसे उनका tenant मिलता है। जो फ़ायरवॉल उनमें से चार को सर्व करता है वह उनमें से किसी का नहीं है, तो उसे कोई tenant नहीं मिलता, और रिश्ता कहीं और जाता है। उस पर और बात आगे, क्योंकि यही वह जगह है जहाँ ज़्यादातर लोगों को पता चलता है कि उन्हें अपना कुछ जोड़ना पड़ेगा।
नंबर Device Type पर डालिए
यही वह स्टेप है जो एक इन्वेंटरी को सवालों का जवाब देने वाली चीज़ से अलग करता है, और इसकी कीमत है हर device type पर करीब दस मिनट।
एक device type अपना वज़न और, अपने power port टेम्पलेट्स के ज़रिए, अपनी पावर खपत साथ रख सकता है। इन्हें एक बार टाइप पर डाल दीजिए और उससे बनाया गया हर डिवाइस इन्हें विरासत में पाएगा। इन्हें छोड़ दीजिए और NetBox खुशी-खुशी आपको बताएगा कि कैबिनेट 28.6% भरी है, और कुछ नहीं।

मैंने यहाँ सभी पाँच टाइप पर वज़न डाला, हर एक को maximum और allocated खपत वाले दो power port टेम्पलेट दिए, PDU टाइप को एक inlet और बारह outlets दिए, फिर एक power panel और कैबिनेट में दो feeds बनाए और सब कुछ केबल से जोड़ा: हर डिवाइस का PSU1 PDU A से, हर PSU2 PDU B से, और हर PDU का inlet उसके feed से।

फिर रैक पेज पूरी तरह बदल जाता है।

जगह का इस्तेमाल 28.6%। पावर का इस्तेमाल 90.7%।
वह कैबिनेट किट से एक तिहाई भरी है और पावर लगभग खत्म, और यह आपकी एस्टेट के बारे में ऐसा तथ्य है जो कोई स्प्रेडशीट कभी खुद नहीं बताएगी। यही तथ्य तय करता है कि अगला ऑर्डर वहाँ रैक होगा या कहीं और, और यह उस डेटा से निकला जो आपने एक बार, टाइप्स पर डाला।
दो चीज़ें जो इसे शून्य दिखाती रहेंगी
शुरू में मुझे 0.0% मिला, दो बार, और दोनों वजहें जानने लायक हैं क्योंकि दोनों में से कोई एरर नहीं देती।
Outlets को inlet का हवाला देना होगा। PDU पर एक power outlet में power_port फ़ील्ड होता है जो उसी डिवाइस के upstream पोर्ट की ओर इशारा करता है। इसे खाली छोड़िए और चेन टूट जाती है: NetBox के पास यह जानने का कोई तरीका नहीं कि वे बारह outlets उस inlet से फ़ीड होते हैं, तो कुछ भी जुड़ता नहीं।
Inlet के draw फ़ील्ड्स खाली छोड़िए। यह उल्टा लगने वाला है। NetBox किसी power port की खपत उसमें लगी चीज़ों से तभी गिनता है जब उसके अपने दोनों draw फ़ील्ड खाली हों:
if self.allocated_draw is None and self.maximum_draw is None:
...aggregate the downstream power ports...
# otherwise
return {'allocated': self.allocated_draw or 0, ...}
मैंने मददगार बनकर PDU inlet पर maximum_draw: 7400 सेट कर दिया था, क्योंकि PDU की रेटिंग यही है। इसलिए NetBox ने मेरी बात मानी, allocated_draw को unset माना, और शून्य दिखाया। दोनों साफ़ कीजिए और वह खुद गिन लेता है:
mcr1-pdu-a INPUT -> allocated 5340 VA, maximum 8480 VA, across 12 outlets
mcr1-pdu-b INPUT -> allocated 5340 VA, maximum 8480 VA, across 12 outlets
feed MCR1-A07-A: available 5888 VA (230 V x 32 A x 80% max utilisation)
RACK power utilisation: 90.7 %
RACK weight: 166.6 kg of 900 kg
तो नियम यह है: पत्तियों पर असली नंबर डालिए, और बीच के पोर्ट्स खाली छोड़िए ताकि NetBox उन्हें जोड़ सके। एडमिन द्वारा परिभाषित वैल्यू हमेशा गिनी गई वैल्यू पर भारी पड़ती है, जो सही व्यवहार है और PDU पर करने के लिए ठीक गलत चीज़।
कूलिंग, जो नई है
वर्शन 4.7 ने DCIM में कूलिंग जोड़ी, और यह उस आधे हिस्से के साथ आई जो महँगा होता जा रहा है। एक रैक air, hybrid या liquid की cooling capability और किलोवाट में क्षमता रखता है; एक device type cooling method रखता है। इनके ऊपर chillers और CRAC यूनिट्स के लिए cooling sources हैं, किसी रैक तक जाने वाले loop को दिखाने वाले cooling feeds हैं, और cold plates और manifolds के लिए खुद डिवाइसों पर intake और outflow कंपोनेंट्स हैं।
ऊपर की कैबिनेट Hybrid, 15.00 kW दिखाती है, क्योंकि मैंने रैक को यही बताया। अगर इस साल आप liquid cooled किट की डिलीवरी ले रहे हैं, तो यह उस चीज़ का मॉडल है जिसे आप अभी स्प्रेडशीट में रख रहे हैं।
एक इंस्टॉल, कई कस्टमर
Tenancy ही वह वजह है कि एक प्रोवाइडर हर कस्टमर के लिए एक के बजाय एक ही NetBox चला सकता है, और यह समझना फ़ायदेमंद है कि यह क्या करती है और, उससे भी ज़रूरी, क्या नहीं करती।
NetBox के अट्ठाईस मॉडलों में tenant फ़ील्ड है। Sites, locations, racks और rack reservations। Devices, cables और virtual device contexts। Prefixes, IP addresses, ranges, aggregates, VLANs, VLAN groups, VRFs, route targets, ASNs। Circuits और circuit groups। Clusters और virtual machines। Tunnels, L2VPNs, wireless LANs और links। Power feeds और cooling feeds।
यह हर वह संज्ञा है जिसका बिल बनता है। इसे लगातार सेट कीजिए और “इस कस्टमर के पास क्या है” एक जाँच-पड़ताल नहीं रह जाता।
लेकिन tenant एक लेबल है, ताला नहीं। यह कहता है कि ऑब्जेक्ट उस कस्टमर के लिए समर्पित है। यह किसी भी लॉग इन कर सकने वाले को सब कुछ पढ़ने से नहीं रोकता, जो एक कंपनी के अंदर ठीक है और उसी पल बेकार है जब किसी कस्टमर का अकाउंट हो।
इससे दो बातें निकलती हैं, और दूसरी वह है जिसे लोग गलत करते हैं।
Tenant का मतलब है समर्पित। जो राउटर सिर्फ़ एक कस्टमर को सर्व करता है उसे उनका tenant मिलता है। जो फ़ायरवॉल उनमें से चार को सर्व करता है वह उनमें से किसी का नहीं, तो उसे कुछ नहीं मिलता, और आप रिश्ता उस चीज़ पर रिकॉर्ड करते हैं जो आपने असल में बेची। साझा किट पर ज़बरदस्ती tenant लगाने से tenancy पर बनी हर रिपोर्ट चुपचाप गलत हो जाती है।
और एक्सेस पूरी तरह अलग तंत्र है।
अलगाव permissions में रहता है
NetBox की object permissions एक JSON constraint लेती हैं, और वह constraint एक Django ORM फ़िल्टर है। यह किसी भी चीज़ के बनने से पहले queryset को छोटा कर देता है, तो हर view, export, API कॉल और search उसके साथ छोटा हो जाता है।

तीन फ़ील्ड काम करते हैं। वे object types जिन पर यह लागू होती है, वे actions जो यह देती है, और नीचे वह constraint। बाकी सब हिसाब-किताब है।
यह रही डिवाइस सूची एडमिनिस्ट्रेटर के रूप में।

और यह वही URL है, वही इंस्टॉल, कस्टमर के रूप में साइन इन करके।

चौदह की जगह दो rows, और बाईं ओर का मेन्यू देखिए। वह सिमटकर उन चार चीज़ों तक रह गया है जिन्हें छूने की उस अकाउंट को अनुमति है। किसी ने इसे कॉन्फ़िगर नहीं किया। नेविगेशन उन्हीं permissions से बनता है, तो कस्टमर को कभी ऐसी किसी चीज़ का लिंक नहीं दिखता जो उसे मना कर दे।
यह मना करने के दो तरीके
यह बारीकी जानने लायक है, क्योंकि दोनों इनकार अलग-अलग बातें कहते हैं और दोनों जानबूझकर हैं।
| कस्टमर का token माँगता है | उसे मिलता है |
|---|---|
/api/dcim/devices/ | 200, दो में से एक row |
/api/dcim/devices/1/, उनका अपना | 200 |
/api/dcim/devices/2/, किसी और का | 404 |
/api/tenancy/tenants/ | 403 |
/api/dcim/sites/, कभी दिया ही नहीं गया | 403 |
| कोई token नहीं | 403 |
404 का मतलब है टाइप आपका है पर वह row नहीं। Constraint ने उसे queryset से हटा दिया, तो जहाँ तक रिक्वेस्ट की बात है, वह मौजूद ही नहीं। वहाँ 403 यह पक्का कर देता कि वह मौजूद है, और एक जिज्ञासु कस्टमर IDs पर चलकर आपकी एस्टेट गिन लेता।
403 का मतलब है टाइप कभी आपका था ही नहीं। Tenants और sites कभी दिए ही नहीं गए, तो वे सीधे मना कर देते हैं, और कस्टमर यह गिन नहीं सकता कि प्लेटफ़ॉर्म पर और कौन है।
फिर उन्हें लिखने दीजिए
Read-only आसान मामला है। असली सवाल यह है कि क्या एडिट अधिकार वाले कस्टमर पर उनके लिए भरोसा किया जा सकता है, तो मैंने उसी constraint के तहत change दिया और बाहर निकलने का रास्ता ढूँढने लगा।
| कोशिश | नतीजा |
|---|---|
| अपना डिवाइस एडिट करना | 200, सेव हुआ |
| दूसरे कस्टमर का डिवाइस एडिट करना | 404 |
| अपना डिवाइस एडिट करके उसे दूसरे कस्टमर के tenant में ले जाना | 403 |
| अपना डिवाइस डिलीट करना | 403, delete कभी दिया ही नहीं गया |
तीसरी row ही असली है। अपना डिवाइस किसी और के tenant को दे देना निकलने का सबसे सीधा रास्ता है, क्योंकि रिक्वेस्ट आने के समय ऑब्जेक्ट आपकी constraint के अंदर होता है और बाद में बाहर। NetBox constraint को उस स्थिति पर जाँचता है जिसमें ऑब्जेक्ट छोड़ा जाएगा, इसलिए वह मना कर देता है। मैंने status code पर भरोसा करने के बजाय डिवाइस वापस पढ़ा, और tenant हिला नहीं था।
घर में बनी ज़्यादातर multi-tenancy यही छेद खुला छोड़ देती है, और इसे आम तौर पर कोई टेस्ट नहीं, कोई कस्टमर ढूँढता है।
ऐसे वेरिएबल जिन्हें विरासत में मिलना चाहिए
यह रहा वह फ़र्क जिसे लोग गलत समझते हैं, और इसे सही करने से बहुत सारी एडिटिंग बचती है।
एक custom field किसी एक ऑब्जेक्ट पर एक वैल्यू है। आप इसे हर ऑब्जेक्ट पर सेट करते हैं, और यह वहीं रहती है। खुद उस चीज़ के बारे में किसी तथ्य के लिए अच्छा: asset tag, सपोर्ट कॉन्ट्रैक्ट नंबर, कमीशनिंग की तारीख।
एक config context किसी विशेषता से जुड़ी वैल्यू है, जिसे उस विशेषता से मेल खाने वाली हर चीज़ विरासत में पाती है। ऐसे वेरिएबल के लिए अच्छा जो नीचे बहना चाहिए: आपके NTP सर्वर, आपके syslog टारगेट, आपकी SNMP community, आपका DNS डोमेन, आपका मैनेजमेंट VLAN, आपकी बैकअप विंडो।
अगर आप पाते हैं कि आप चालीस डिवाइसों पर एक ही custom field को एक ही वैल्यू पर सेट कर रहे हैं, तो आपको config context चाहिए था।

Context कोई भी JSON हो सकता है, और इसे region, site group, site, location, device type, role, platform, cluster, cluster type, cluster group, tenant group, tenant या tag से जोड़ा जा सकता है। उस सूची में tenant है, जिसका प्रोवाइडर के लिए मतलब है कि किसी एक कस्टमर के बारे में हर जगह सच तथ्य उनके लिए जोड़े गए हर डिवाइस पर उनके पीछे-पीछे जाता है।
मर्ज हर key पर अलग होता है, और weight तय करता है कि हर key पर कौन जीतेगा।

दाएँ पैनल को बाएँ के सामने पढ़िए। Region weight 1000 पर चार keys देता है। Site weight 2000 पर एक key देती है। Rendered context region का domain, NTP सर्वर और community बिना छुए रखता है, और site का syslog सर्वर ले लेता है, क्योंकि सिर्फ़ उसी key पर किसी ने दावा किया था।
आप अपवाद लिखते हैं, अपवाद समेत हर चीज़ की नई कॉपी नहीं। पूरी कीमत यही है, और इसीलिए यह वहाँ स्केल करता है जहाँ हर डिवाइस की वेरिएबल फ़ाइल नहीं करती।
Local context अपने ऊपर की हर चीज़ पर भारी है
विरासत के ढेर का एक शिखर है, और वह खुद ऑब्जेक्ट है। किसी डिवाइस पर local context data उस पर लागू हर source context पर भारी पड़ता है, उनके weight चाहे जो हों।
मैंने इसे mcr1-core-01 पर सेट किया:
{"syslog_servers": ["10.20.10.99"], "note": "this box logs somewhere else"}
और उसका rendered context यह बन गया:
{
"note": "this box logs somewhere else",
"domain": "mcr1.example.net",
"ntp_servers": ["172.16.10.22", "172.16.10.33"],
"snmp_community": "n0rthwest",
"syslog_servers": ["10.20.10.99"]
}

Local syslog सर्वर ने weight 2000 वाले site override और weight 1000 वाले region, दोनों को हरा दिया। जिस चीज़ के बारे में इसने कुछ नहीं कहा वह सब अब भी विरासत में आया, तो domain, NTP सर्वर और community बिना छुए आए, और नई key बस जुड़ गई।
यह उस एक बॉक्स के लिए आपातकालीन रास्ता है जो सच में अलग है, और पैनल साफ़ बताता है कि यह सभी source contexts को overwrite करता है। अगर आप पाते हैं कि आप इसे एक के बजाय कई डिवाइसों पर इस्तेमाल कर रहे हैं, तो आपने एक ऐसी विशेषता ढूँढ ली है जो उन डिवाइसों में साझा है और आपको उस पर scoped एक context चाहिए था।
तीन जाल
बिना scope वाला context global होता है। एक बनाइए और उसे किसी चीज़ को असाइन करना भूल जाइए, और वह आपके हर डिवाइस और वर्चुअल मशीन पर लागू हो जाता है। यह डॉक्यूमेंटेड व्यवहार है और कभी-कभी आप यही चाहते हैं। यह चुपचाप भी होता है।
अगर आप keys तक आसानी से पहुँचना चाहते हैं तो उनमें hyphen नहीं हो सकते। Context data JSON है, तो ntp-servers बिल्कुल वैध है, लेकिन Jinja वेरिएबल नाम JSON keys नहीं हैं। {{ ntp-servers }} घटाव की तरह पार्स होता है और UndefinedError: 'ntp' is undefined देता है। hyphen वाले डेटा पर {{ ntp_servers }} लिखिए और आपको एक खाली स्ट्रिंग मिलती है, HTTP 200, और कहीं कोई चेतावनी नहीं। Keys में underscore इस्तेमाल कीजिए और सीधा-सादा टेम्पलेट काम करता है।
एक profile टाइपो रोक सकता है। Config context profile संबंधित contexts को एक साथ रखता है और सेव के समय उनके डेटा पर एक JSON schema लागू करता है। मैंने एक को ऐसा schema दिया जिसमें syslog_servers का IPv4 स्ट्रिंग्स का array होना ज़रूरी था, फिर वे दो गलतियाँ कीं जो लोग असल में करते हैं:
{"syslog-server": ["10.1.1.1"]} singular, by accident
400 Data does not conform to profile schema:
'syslog-servers' is a required property
{"syslog_servers": [...], "syslog_port": 99999}
400 Data does not conform to profile schema:
99999 is greater than the maximum of 65535
वहीं ठुकराई गईं जहाँ किसी ने उन्हें किया, चार सौ डिवाइस बाद नहीं।
कॉन्फ़िगरेशन रेंडर करना
Context data और एक Jinja टेम्पलेट मिलकर आपको एक कॉन्फ़िगरेशन फ़ाइल देते हैं। डिवाइस device के रूप में scope में है, उसका मर्ज किया गया context आम वेरिएबल्स के रूप में scope में है, और आप उसके कंपोनेंट्स पर चल सकते हैं।

उस पेज पर हर चीज़ अलग-अलग जगह से आई, और यही असली बात है:
| लाइन | कहाँ से आई |
|---|---|
host-name mcr1-core-01 | डिवाइस से |
domain-name mcr1.example.net | रीजन के config context से |
location "Manchester DC1 / MCR1-A07 / U39" | साइट, रैक और उसमें पोज़िशन से |
server 172.16.10.22 | रीजन के context से, weight 1000 |
host 10.20.10.99 any notice | डिवाइस के अपने local context से, जो साइट और रीजन दोनों पर भारी पड़ा |
family inet address 10.20.10.11/24 | उस इंटरफ़ेस के एड्रेस से, मास्क वैसा ही जैसा टाइप किया गया |
टेम्पलेट पहले डिवाइस, फिर role, फिर platform से तय होता है, और अगर तीनों में से किसी के पास नहीं है तो रिक्वेस्ट फ़ेल हो जाती है। तो आप एक बार किसी platform को टेम्पलेट असाइन करते हैं, और उस सॉफ़्टवेयर पर चलने वाला हर डिवाइस उसी से रेंडर होता है, जब तक उसका role या खुद डिवाइस कुछ और न कहे। Platform इसी के लिए है: ऑपरेटिंग सिस्टम या वेंडर सॉफ़्टवेयर फ़ैमिली, हार्डवेयर नहीं।
NetBox रेंडर करता है। पुश नहीं करता। आउटपुट को बॉक्स तक पहुँचाना आपके ऑटोमेशन का काम है, और जिस दिन टेम्पलेट का कोई बग वरना चार सौ डिवाइस दोबारा कॉन्फ़िगर कर देता, उस दिन आप खुश होंगे कि ये दो अलग सिस्टम हैं।
प्लगइन
प्लगइन NetBox के साथ इंस्टॉल किया गया एक Django एप्लिकेशन है। यह मॉडल जोड़ सकता है, पेज जोड़ सकता है, दोनों APIs बढ़ा सकता है, मौजूदा टेम्पलेट्स में कंटेंट डाल सकता है, नेविगेशन जोड़ सकता है, बैकग्राउंड जॉब क्यू जोड़ सकता है और आगे के Django apps लोड कर सकता है। ऐसा बहुत कम है जो यह नहीं कर सकता, क्योंकि नीचे से यह बस Django है।
एक इंस्टॉल करना चार कमांड और एक रीस्टार्ट है:
source /opt/netbox/venv/bin/activate
pip install netbox-topology-views netbox-qrcode
# add the package names to PLUGINS in configuration.py, then
python3 manage.py migrate
python3 manage.py collectstatic --no-input
sudo systemctl restart netbox netbox-rq
कंटेनर स्टैक पर वही पैकेज plugin_requirements.txt में जाते हैं और आप इमेज दोबारा बनाते हैं। दोनों तरह से, वर्शन पिन कीजिए और पहले compatibility matrix देखिए, क्योंकि जो प्लगइन किसी NetBox रिलीज़ के साथ कदम नहीं मिला पाया वह खुद को बंद करने के बजाय पूरे एप्लिकेशन को शुरू होने से मना कर देगा।

प्रकाशित कैटलॉग में 31 हैं। ये वे हैं जिनके बारे में जानना फ़ायदेमंद है, उस लाइसेंस के साथ जिसके तहत हर एक असल में आता है:
| प्लगइन | क्या करता है | लाइसेंस |
|---|---|---|
| DNS | source of truth के रूप में zones, records और name servers | MIT |
| BGP | Sessions, communities और routing policies | Apache 2.0 |
| Topology Views | आपकी केबलों से बने ग्राफ़िकल topology मैप | Apache 2.0 |
| Floorplan | ग्राफ़िकल site और location मैप | LGPL 3.0 |
| QR Code | asset लेबल के लिए racks, devices और cables पर कोड | Apache 2.0 |
| ACLs | Access lists और rules | Apache 2.0 |
| Prometheus SD | Prometheus को उसकी होस्ट सूची सीधे NetBox से देता है | MIT |
| Documents | circuits और devices से जुड़े डॉक्यूमेंट | Apache 2.0 |
| Lifecycle | हार्डवेयर end of life, लाइसेंस और कॉन्ट्रैक्ट | Apache 2.0 |
| Contract | कॉन्ट्रैक्ट और इनवॉइस | MIT |
| Reorder Rack | रैक यूनिट्स को drag and drop करना | Apache 2.0 |
| Branching | आपके डेटा की अलग-थलग, मर्ज की जा सकने वाली branches | NetBox Limited Use |
| Custom Objects | UI में परिभाषित नए object types | NetBox Limited Use |
Prometheus SD पूरे विचार का ईमानदार रूप है। NetBox जानता है कि क्या मौजूद है, तो NetBox को ही मॉनिटरिंग सिस्टम को बताने दीजिए, और होस्ट्स की एक दूसरी सूची मेंटेन करना बंद कीजिए जो भटकती रहती है।
आखिरी दो rows पर कुछ बनाने से पहले एक बात जान लीजिए। NetBox खुद Apache 2.0 है और 2016 में DigitalOcean के रिलीज़ करने के बाद से है, और आज इस प्रोजेक्ट की देखरेख NetBox Labs वॉलंटियर मेंटेनरों की एक टीम के साथ करती है।21 NetBox Branching और NetBox Custom Objects ऐसे नहीं हैं: ये NetBox Limited Use License 1.0 के तहत आते हैं, जो इस्तेमाल की अनुमति देता है “only as part of a NetBox installation obtained from NetBox Labs or a NetBox distributor authorized by NetBox Labs, and only for your own internal use”, और जो सॉफ़्टवेयर इस्तेमाल करने का अधिकार नहीं देता “to provide a managed service or software products that includes, integrates with, or extends NetBox in a way that competes with any product or service of NetBox Labs”। अगर आपने NetBox Community GitHub से इंस्टॉल किया है और इसे कस्टमरों की ओर से चलाते हैं, तो उनके पीछे कोई schema लगाने से पहले शर्तें खुद पढ़िए।10 NetBox की अपनी इंस्टॉलेशन गाइड इसका ज़िक्र किए बिना दोनों प्लगइन की सिफ़ारिश करती है।11
Custom Fields
Custom field किसी मौजूदा मॉडल में एक attribute जोड़ता है। वैल्यू हर ऑब्जेक्ट के साथ JSON के रूप में स्टोर होती हैं, तो कोई migration नहीं और कोई रीस्टार्ट नहीं, और तेरह टाइप हैं जिनमें दूसरे NetBox रिकॉर्ड्स के object और multi-object references भी शामिल हैं।

वहाँ दो फ़ील्ड हैं, मेरे चुने हुए “Asset” हेडिंग के नीचे। उनके दाईं ओर Dimensions पैनल देखिए: 9.5 kg, जो इस डिवाइस पर किसी ने टाइप नहीं किया। यह device type से आया।
Custom fields वैलिडेट होते हैं, और यह जानना फ़ायदेमंद है, क्योंकि नीचे वाले रास्ते से यह एक असली फ़र्क है। मैंने कॉन्ट्रैक्ट फ़ील्ड को एक regular expression दिया और API ने उसे लागू किया:
PATCH {"custom_fields": {"support_contract": "nonsense"}}
{"__all__": ["Invalid value for custom field 'support_contract':
Value must match regex '^[A-Z]{2,4}-[0-9]{6}$'"]}
4.7 में दो चीज़ें बदलीं जो बड़े पैमाने पर मायने रखती हैं। डिफ़ॉल्ट वैल्यू वाला फ़ील्ड बनाना, या कोई फ़ील्ड डिलीट करना, हर उस ऑब्जेक्ट का स्टोर किया डेटा दोबारा लिखता है जिस पर वह लागू होता है, तो बड़ी टेबल पर वह काम एक बैकग्राउंड जॉब को सौंपा जाता है और चलते समय फ़ील्ड “provisioning” या “deleting” दिखाता है। फ़ील्ड सिर्फ़ active रहते हुए ही लाइव होता है: इन दोनों में से किसी भी ऑपरेशन के दौरान वह ऑब्जेक्ट्स पर, फ़ॉर्म्स में, फ़िल्टर्स में या किसी भी API में नहीं दिखता। इसके लिए एक वर्कर का चलना ज़रूरी है, वरना यह उसी हालत में अनिश्चित काल तक पड़ा रहता है।
जब आप खुद उस चीज़ के बारे में कोई तथ्य जोड़ रहे हों तो custom field इस्तेमाल कीजिए। जब वैल्यू नीचे बहनी चाहिए तो config context। जब जिस चीज़ की आपको ज़रूरत है वह मौजूद ही न हो, तो अगला सेक्शन।
Custom Select मेन्यू, और जो साथ आता है उसे बदलना
इस हेडिंग के नीचे दो अलग तंत्र हैं और वे अलग समस्याएँ हल करते हैं। एक आपके अपने फ़ील्ड्स के लिए है। दूसरा NetBox के फ़ील्ड्स को दोबारा लिखता है।
Choice set, आपके अपने select फ़ील्ड के लिए
“selection” टाइप का custom field अपने विकल्प एक choice set से लेता है, जो एक ऑब्जेक्ट है जिसे आप UI में किसी भी दूसरी चीज़ की तरह मैनेज करते हैं। तो “support tier” एक असली dropdown बन जाता है, न कि फ़्री टेक्स्ट जिसे कोई तीन तरह से लिखेगा।

यह लागू होता है, API के ज़रिए भी:
PATCH {"custom_fields": {"support_tier": "platinum"}}
{"__all__": ["Invalid value for custom field 'support_tier':
Invalid choice (platinum) for choice set Support tier."]}
Choice sets साझा होते हैं, तो एक सेट कई मॉडलों पर एक ही फ़ील्ड को चला सकता है, और एक जगह सूची बदलने से वह हर जगह बदल जाती है।
FIELD_CHOICES, NetBox के अपने फ़ील्ड्स के लिए
यह वह है जिसके होने का लोगों को पता ही नहीं। NetBox के कई built-in choice फ़ील्ड्स को configuration.py से बढ़ाया या बदला जा सकता है, जिनमें device status, site status, rack status, circuit status और बहुत कुछ शामिल है।12
जो साथ आता है उसमें जोड़ने के लिए आखिर में plus का निशान लगाइए। सूची पूरी तरह बदलने के लिए उसे छोड़ दीजिए।
FIELD_CHOICES = {
# add to what NetBox ships with
'dcim.Device.status+': (
('burn-in', 'Burn-in', 'cyan'),
{'value': 'awaiting-rma', 'label': 'Awaiting RMA', 'color': 'orange',
'description': 'Faulty, with the vendor'},
),
# replace the stock list outright
'dcim.Site.status': (
('surveyed', 'Surveyed', 'purple'),
('building', 'Building out', 'orange'),
('active', 'Active', 'green'),
('closing', 'Closing', 'red'),
),
}
मैंने इस इंस्टेंस पर ठीक यही डाला। Device status सात स्टॉक वैल्यू और मेरी दो के साथ लौटा:
offline, active, planned, staged, failed, inventory, decommissioning,
burn-in, awaiting-rma
और site status सिर्फ़ मेरी वैल्यू के साथ लौटा, स्टॉक सूची गायब:
surveyed, building, active, closing
एक choice value, label और colour का सादा tuple हो सकता है, या एक dictionary जो एक description भी लेती है जो फ़ॉर्म में subtitle की तरह दिखता है। और ये हर जगह native वैल्यू की तरह बर्ताव करते हैं, क्योंकि जहाँ तक बाकी NetBox का सवाल है, ये native वैल्यू ही हैं:

वह badge मेरा status है, मेरे रंग में, किसी भी दूसरे की तरह sort और filter होता हुआ।
इसे इस्तेमाल करने से पहले तीन बातें जानने लायक हैं।
बदलने से स्टॉक वैल्यू मेन्यू से हटती हैं, डेटाबेस से नहीं। जिस ऑब्जेक्ट के पास पहले से उनमें से कोई वैल्यू है वह उसे रखता है, लेकिन वह वैल्यू अब पेश नहीं की जाती और अगली बार कोई उस ऑब्जेक्ट को एडिट करे तो वह वैध विकल्प नहीं होगी। अगर आप कोई सूची बदलते हैं, तो जाँच लीजिए कि कोई चीज़ उस वैल्यू पर तो नहीं बैठी जिसे आपने अभी हटाया।
यह कॉन्फ़िगरेशन फ़ाइल में रहता है, तो इसे रीस्टार्ट चाहिए और इसे कोई UI यूज़र नहीं बदल सकता। प्रोवाइडर के लिए यही सही तरीका है: आपका बिज़नेस किन स्टेटस को मानता है, यह गवर्नेंस का फ़ैसला है, किसी मंगलवार दोपहर का नहीं।
बदलने से पहले बढ़ाइए। स्टॉक वैल्यू वही हैं जिन्हें हर प्लगइन, स्क्रिप्ट और इंटीग्रेशन देखने की उम्मीद करता है। जोड़ने में कुछ खर्च नहीं होता। बदलना एक ऐसा फ़ैसला है जो हमेशा के लिए आपका है।
Custom Objects
यह रही एक असली कमी। NetBox clusters, virtual machines और virtual disks मॉडल करता है। वह उस datastore को मॉडल नहीं करता जिस पर वे डिस्क असल में रहती हैं, और Proxmox या VMware चलाने वाले किसी के लिए भी यही वह ऑब्जेक्ट है जो आपके खरीदे स्टोरेज को उसे इस्तेमाल करने वाले वर्कलोड से जोड़ता है।
Custom Objects प्लगइन आपको बिना कोई कोड लिखे UI या API से एक नया object type परिभाषित करने देता है। तो:

सात फ़ील्ड, जिनमें से दो ही असली बात हैं। cluster एक असली NetBox cluster का single object reference है, protect पर सेट, ताकि कोई किसी cluster को उसके स्टोरेज के नीचे से डिलीट न कर सके। provisioned_by उन डिवाइसों का multi-object reference है जो असल में इसे सर्व करते हैं।
इससे आपको एक पूरा-पूरा ऑब्जेक्ट मिलता है, अपनी नेविगेशन एंट्री, list view, filters, import और export के साथ:

और क्योंकि references असली हैं, रिश्ता दूसरे सिरे से भी दिखता है। Cluster खोलिए और datastores उसके सामने सूचीबद्ध हैं।

एक custom object type वह ज़्यादातर चीज़ें विरासत में पाता है जो किसी NetBox ऑब्जेक्ट को NetBox ऑब्जेक्ट बनाती हैं: list और detail views, एक नेविगेशन एंट्री, REST endpoints, full-text search, change logging, journaling, tags, bookmarks, import और export, event rules और notifications। इनमें से कुछ भी लिखना नहीं पड़ा।
यह टेबल होने का नाटक करता कोई JSON blob भी नहीं है। प्लगइन असली DDL चलाता है, और PostgreSQL में जो दिखता है वह असली constraints वाली एक असली टेबल है:
Table "public.custom_objects_2"
Column | Type | Nullable | Default
-----------------+----------+----------+------------------
id | bigint | not null | identity
name | varchar | |
cluster_id | bigint | |
backing | varchar | |
capacity_gb | bigint | |
thin_provisioned| boolean | |
Indexes:
"custom_objects_2_name_key" UNIQUE CONSTRAINT, btree (name)
Foreign-key constraints:
... FOREIGN KEY (cluster_id) REFERENCES virtualization_cluster(id) ON DELETE RESTRICT
मैंने जो protect माँगा था वह ON DELETE RESTRICT बन गया, और यह काम करता है: उस cluster को डिलीट करने पर 409 लौटता है, जो बताता है कि उस पर क्या निर्भर है।
इस पर भरोसा करने से पहले दो बातें
वैलिडेशन फ़ॉर्म पर है, API पर नहीं। यही वह है जो किसी ऑटोमेशन को पकड़ लेगा। मैंने एक custom object type के फ़ील्ड्स पर required, एक regular expression और संख्या की सीमाएँ घोषित कीं, और फिर REST API से उनमें लिखा:
| मैंने क्या घोषित किया | मैंने क्या भेजा | नतीजा |
|---|---|---|
validation_regex | ऐसी वैल्यू जो किसी से मेल नहीं खाती | 201 Created |
required: true | फ़ील्ड पूरी तरह छोड़ दिया | 201 Created |
validation_minimum: 1 | एक ऋणात्मक संख्या | 201 Created |
unique: true | एक डुप्लिकेट | 400, ठुकराया |
on_delete_behavior: protect | संदर्भित ऑब्जेक्ट डिलीट करना | 409, ठुकराया |
जो दो टिके वे वही दो हैं जो डेटाबेस constraints बने। बाकी सिर्फ़ वेब फ़ॉर्म पर मौजूद हैं, तो टाइप करता इंसान बँधा है और रात की sync नहीं। इसकी तुलना ऊपर वाले core custom field से कीजिए, जहाँ वही regular expression API से लागू हुआ। जब तक यह नहीं बदलता, जिस भी चीज़ पर कोई इनवॉइस निर्भर है उसे किसी असली constraint के पीछे रखिए।
टाइप डिलीट करने से एक टेबल ड्रॉप होती है। फ़ील्ड डिलीट करने से एक कॉलम ड्रॉप होता है। यह वेब फ़ॉर्म से चलने वाला DDL है, जिसे वह चलाता है जिसके पास permission है, और डॉक्यूमेंटेशन भी यही कहता है।13 इन्हें कौन डिलीट कर सकता है, इसे सीमित रखिए।
कब इसके बजाय असली प्लगइन लिखें
अगर ऑब्जेक्ट मायने रखता है, अगर ऑटोमेशन उसमें लिखता है, और अगर उसमें कचरा मिलने पर आप परेशान होंगे, तो मॉडल खुद लिखिए। एक न्यूनतम NetBox प्लगइन एक PluginConfig, एक मॉडल, एक serializer, एक viewset, एक table, एक form, कुछ views और एक URL map है, और यह दो सौ लाइनों से कम का बनता है, ज़्यादातर घोषणाएँ। PrimaryModel को subclass करने से आपको tags, custom fields, change logging, journaling, export templates और ownership मुफ़्त में मिलते हैं, और मॉडल पर लगाई हर constraint हर जगह लागू होती है, क्योंकि NetBox की अपनी serializer मशीनरी उसे चलाती है।
कम्युनिटी एक cookiecutter template और एक पूरा plugin tutorial मेंटेन करती है। खाली डायरेक्टरी के बजाय वहीं से शुरू कीजिए।
और लाइसेंस वही होता है जो आप चुनें, जिसे बाद में कोई नहीं बदल सकता।
Custom Validation, और Validation क्लासें
ऊपर सब कुछ यह रिकॉर्ड करने के बारे में है कि वहाँ क्या है। यह उस चीज़ को रिकॉर्ड करने से मना करने के बारे में है जो नहीं होनी चाहिए।
NetBox हर ऑब्जेक्ट को लिखने से पहले वैलिडेट करता है, और आप उसके ऊपर अपने नियम जोड़ सकते हैं। तीन तंत्र हैं, तीनों configuration.py में रहते हैं, और मिलकर वे लगभग वह सब कवर करते हैं जो किसी हाउस स्टैंडर्ड को चाहिए।
एक: सादे नियम, कोई कोड नहीं
Validator फ़ील्ड नामों से शर्तों की एक सादी mapping हो सकता है। कोई Python नहीं, और यह इंस्टॉलों के बीच ले जाया जा सकता है क्योंकि यह बस डेटा है।
CUSTOM_VALIDATORS = {
'dcim.site': (
{'description': {'required': True}},
),
'dcim.device': (
{'name': {'regex': r'^[a-z0-9]+-[a-z]+-([0-9]{2}|[a-z])$'}},
),
}
उपलब्ध शर्तें हैं min, max, min_length, max_length, regex, required, prohibited, eq और neq। आप dotted path से किसी संबंधित ऑब्जेक्ट तक पहुँच सकते हैं, तो site पर region.name पूरी तरह जायज़ है, और आप request.user.username पर भी मैच कर सकते हैं, हालाँकि डॉक्यूमेंटेशन बिल्कुल सही कहता है कि इसके लिए permissions इस्तेमाल कीजिए।
दोनों नियम तुरंत चलते हैं:
POST a site with no description
{"__all__": ["Custom validation failed for description:
['This field must not be empty.']"]}
POST a device named "Server1"
{"__all__": ["Custom validation failed for name: ['Enter a valid value.']"]}
वह दूसरा एक नामकरण स्टैंडर्ड है, लागू किया हुआ। किसी विकी पेज पर लिखा नहीं, किसी के दिमाग में नहीं, ऐसी चीज़ नहीं जिसके लिए नए आए इंसान को तीन हफ़्ते बाद किसी रिव्यू में डाँट पड़े। डेटाबेस इसे लेगा ही नहीं।
दो: validator क्लास, जब नियम एक वाक्य हो
सादे नियम एक फ़ील्ड को एक स्थिरांक से जाँचते हैं। असली हाउस नियम आम तौर पर शर्तों वाले होते हैं: यह तभी मायने रखता है जब वह। इनके लिए आप CustomValidator को subclass करते हैं, validate() को override करते हैं, और fail() कॉल करते हैं।
मैंने तीन /opt/netbox/netbox/house_rules.py पर एक मॉड्यूल में रखे:
from extras.validators import CustomValidator
class BillableKitNamesItsCustomer(CustomValidator):
"""Anything in a role we sell has to say whose it is."""
BILLABLE_ROLES = {'hypervisor'}
def validate(self, instance, request):
role = getattr(instance, 'role', None)
if role and role.slug in self.BILLABLE_ROLES and not instance.tenant:
self.fail(
f"A {role} is billable kit, so it must name the customer it belongs to.",
field='tenant',
)
class RackedDeviceNeedsAPosition(CustomValidator):
"""A device in a rack with no rack unit is a device nobody can find."""
def validate(self, instance, request):
if instance.rack and instance.position is None:
if instance.device_type and instance.device_type.u_height:
self.fail(
"A device in a rack needs a rack unit. Somebody has to find it.",
field='position',
)
class CustomerPrefixNeedsATenant(CustomValidator):
"""A customer prefix that names no customer cannot be billed."""
def validate(self, instance, request):
role = getattr(instance, 'role', None)
if role and role.slug == 'customer' and not instance.tenant:
self.fail(
"A customer prefix must be assigned to a tenant.",
field='tenant',
)
और उन्हें dotted path से जोड़ा:
CUSTOM_VALIDATORS = {
'dcim.device': (
{'name': {'regex': r'^[a-z0-9]+-[a-z]+-([0-9]{2}|[a-z])$'}},
'house_rules.BillableKitNamesItsCustomer',
'house_rules.RackedDeviceNeedsAPosition',
),
'ipam.prefix': (
'house_rules.CustomerPrefixNeedsATenant',
),
}
ध्यान दीजिए कि एक मॉडल validators का एक tuple लेता है, सादे नियम और क्लासें आपस में मिली हुई, और सब चलते हैं। एक अकेला validator भी iterable के रूप में ही देना पड़ता है, जिसमें पाँच मिनट आसानी से बर्बाद हो जाते हैं।
फिर नियम वही करते हैं जो वे कहते हैं:
POST a hypervisor with no tenant
{"tenant": ["A Hypervisor is billable kit, so it must name
the customer it belongs to."]}
POST a device into a rack with no position
{"position": ["A device in a rack needs a rack unit.
Somebody has to find it."]}
POST a prefix with role "customer" and no tenant
{"tenant": ["A customer prefix must be assigned to a tenant."]}
POST a leaf switch with no tenant
accepted, because a leaf switch is not in BILLABLE_ROLES
क्योंकि fail() एक field लेता है, मैसेज पेज के ऊपर नहीं बल्कि फ़ॉर्म में सही बॉक्स पर आता है, और यही फ़र्क है उस नियम में जिसे लोग सीख लेते हैं और उस नियम में जिससे लोग चिढ़ते हैं।
custom objects वाले सेक्शन की कमी का जवाब भी यही है। वहाँ का वैलिडेशन सिर्फ़ वेब फ़ॉर्म पर था। CustomValidator मॉडल लेयर में चलता है, तो यह UI, REST API, GraphQL mutations, bulk imports और किसी भी स्क्रिप्ट के काम पर लागू होता है। नियम लिखने की एक जगह है और उसके इर्द-गिर्द कोई रास्ता नहीं।
तीन: protection rules, डिलीट के लिए
CUSTOM_VALIDATORS लिखने की रखवाली करता है। PROTECTION_RULES डिलीट की रखवाली करता है, और यह ठीक वही दो रूप लेता है।
PROTECTION_RULES = {
'dcim.device': (
{'status': {'eq': 'offline'}},
),
}
यह कहता है कि कोई डिवाइस तभी डिलीट हो सकता है जब वह offline हो। जिसका नतीजा:
DELETE an active device
{"detail": "Deletion is prevented by a protection rule:
[\"Custom validation failed for status:
['Ensure this value is equal to offline.']\"]"}
set it to offline, then DELETE
204 No Content
किसी इंसान और एक लाइव डिवाइस के बीच दो कीस्ट्रोक की रुकावट, और यह पूरे एप्लिकेशन का सबसे सस्ता बीमा है। Decommissioning प्रोसेस को ही वह चीज़ बनाइए जो delete बटन खोलती है।
वह जो आपको पकड़ लेगा
मौजूदा डेटा तब तक जाँचा नहीं जाता जब तक आप उसे अगली बार छूते नहीं। नियम जोड़ने से पहले से मौजूद चीज़ें वापस जाकर वैलिडेट नहीं होतीं। यह चुपचाप बैठा रहता है जब तक कोई ऐसा ऑब्जेक्ट सेव न करे जो इसे तोड़ता है, और फिर उन्हें एक ऐसे फ़ैसले के बारे में एरर मिलता है जिससे उनका कोई लेना-देना नहीं था।
मैंने इसे होते देखा। mcr1-hv-06 मेरे यह सब लिखने से पहले बना था, बिना tenant वाले एक हाइपरवाइज़र के रूप में। वह बिल्कुल आराम से वहाँ पड़ा था। फिर मैंने उसका description एडिट किया:
PATCH {"description": "touching it to trigger revalidation"}
{"tenant": ["A Hypervisor is billable kit, so it must name
the customer it belongs to."]}
एडिट का tenant से कोई लेना-देना नहीं था। नियम फिर भी चला, क्योंकि वैलिडेशन पूरे ऑब्जेक्ट पर चलता है।
यह सही व्यवहार है और यही वह तरीका भी है जिससे एक नया नियम सपोर्ट टिकट बन जाता है। किसी नियम को चालू करने से पहले उन ऑब्जेक्ट्स के लिए query चलाइए जो उसमें फ़ेल होंगे और पहले उन्हें ठीक कीजिए। API इसे आसान बनाता है: नियम एक फ़िल्टर है, तो उस role वाले और बिना tenant वाले डिवाइस माँगिए, और आपकी सूची तैयार है।
नियम उसके बाद चालू कीजिए। फिर वह सिर्फ़ नई गलतियाँ पकड़ता है, और वह इसी के लिए है।
इसे Ansible से चलाना
जिस source of truth को कोई नहीं पढ़ता वह सड़ जाएगा। netbox.netbox collection वह तरीका है जिससे ज़्यादातर लोग ऐसा होने से रोकते हैं, और यह दोनों दिशाओं में काम करता है: NetBox Ansible को बताता है कि क्या मौजूद है, और Ansible NetBox को बताता है कि उसने क्या बनाया।
यह वर्शन 3.23.0 पर है, GPL-3.0 लाइसेंस के तहत, और Galaxy से 13.4 मिलियन से ज़्यादा बार डाउनलोड हुआ है। इसमें 91 मॉड्यूल और एक inventory प्लगइन है।14 नीचे सब कुछ उसी इंस्टेंस पर चलाया गया, एक ऐसे कंटेनर से जिसमें ansible-core 2.21.4, pynetbox 7.8.0 और collection के अलावा कुछ नहीं था।
इन्वेंटरी एक query है, फ़ाइल नहीं
यही वह आधा हिस्सा है जो पहली ही दोपहर में अपनी कीमत वसूल लेता है। nb_inventory आपकी Ansible इन्वेंटरी सीधे NetBox से बनाता है:
plugin: netbox.netbox.nb_inventory
api_endpoint: http://netbox:8080
token: "{{ lookup('env', 'NETBOX_TOKEN') }}"
config_context: false
group_by:
- sites
- device_roles
- tenants
- racks
device_query_filters:
- has_primary_ip: true
इससे यह बनता है, बिना किसी के होस्ट सूची मेंटेन किए:
@sites_manchester-dc1: @device_roles_hypervisor:
|--mcr1-core-01 |--mcr1-hv-01
|--mcr1-core-02 |--mcr1-hv-02
|--mcr1-hv-01 |--mcr1-hv-03
|--mcr1-hv-02 |--mcr1-hv-04
... |--mcr1-hv-05
@racks_MCR1-A07: @tenants_ravenscroft-legal:
|--mcr1-core-01 |--mcr1-hv-01
|--mcr1-core-02 |--mcr1-hv-02
... @tenants_padgate-foods:
@device_roles_core-router: |--mcr1-hv-03
|--mcr1-core-01 |--mcr1-hv-04
|--mcr1-core-02 @tenants_hartley-components:
|--mcr1-hv-05
दाएँ कॉलम को देखिए। क्योंकि डिवाइसों पर tenancy सेट है, आपको हर कस्टमर का एक ग्रुप मुफ़्त में मिलता है, तो --limit tenants_ravenscroft-legal ठीक एक कस्टमर की किट पर play चलाता है। NetBox में एक डिवाइस जोड़िए और अगले रन पर वह ग्रुप में है। एक को decommission कीजिए और वह चला गया। कोई कुछ एडिट नहीं करता।
हर होस्ट वह सब साथ लेकर आता है जो NetBox उसके बारे में जानता है:
ansible_host "2001:db8:20:20::11"
primary_ip4 "10.20.20.11"
primary_ip6 "2001:db8:20:20::11"
device_roles ["hypervisor"]
sites ["manchester-dc1"]
racks ["MCR1-A07"]
tenants ["ravenscroft-legal"]
device_types ["sys-1029u-tn10rt"]
manufacturers ["supermicro"]
status {"label": "Active", "value": "active"}
कुल बाईस keys, और उनमें से एक आपको चौंकाने से पहले ध्यान देने लायक है। ansible_host IPv6 एड्रेस है, क्योंकि उस डिवाइस पर primary v6 सेट है। मैंने इसे दो और डिवाइसों से जाँचा जिनके पास सिर्फ़ v4 है और वे v4 के साथ लौटे, तो नियम यह है कि जहाँ primary v6 मौजूद है वहाँ प्लगइन v6 को तरजीह देता है। जो सही है, और यह उस तरह की चीज़ भी है जिसे आप अभी पता करना पसंद करेंगे, बजाय यह सोचते हुए कि कोई play ऐसे रास्ते से क्यों जुड़ रहा है जिसके बारे में आपने सोचा ही नहीं था।
वापस लिखना
मॉड्यूल दूसरी दिशा हैं, और जो रखने लायक है वह IP allocation है, क्योंकि NetBox जानता है कि क्या खाली है और आपकी playbook नहीं जानती।
- name: Rack the device
netbox.netbox.netbox_device:
netbox_url: "{{ nb_url }}"
netbox_token: "{{ nb_token }}"
data:
name: mcr1-hv-07
device_type: SYS-1029U-TN10RT
device_role: Hypervisor
site: Manchester DC1
rack: MCR1-A07
position: 14
face: Front
tenant: Hartley Components
state: present
- name: Let NetBox pick the next free address out of the customer prefix
netbox.netbox.netbox_ip_address:
netbox_url: "{{ nb_url }}"
netbox_token: "{{ nb_token }}"
data:
prefix: 10.20.22.0/24
tenant: Hartley Components
assigned_object:
device: mcr1-hv-07
name: eno1
state: new
देखिए उसमें क्या नहीं है। कोई IP एड्रेस नहीं। आप prefix का नाम देते हैं और NetBox अगला खाली एड्रेस लौटा देता है:
TASK [Let NetBox pick the next free address out of the customer prefix] ****
changed: [localhost]
"device : mcr1-hv-07 (created)"
"interface: eno1 (created)"
"address : 10.20.22.1/24 (allocated)"
और एक सेकंड बाद यह UI में मौजूद है, अभी किसी से केबल नहीं जुड़ी पर रैक किया हुआ, tenant और एड्रेस के साथ:

उस playbook का जाल
इसे एक भी लाइन बदले बिना दूसरी बार चलाइए और यह होता है:
"device : mcr1-hv-07 (already correct)"
"interface: eno1 (already correct)"
"address : 10.20.22.2/24 (allocated)"
डिवाइस और इंटरफ़ेस idempotent हैं। एड्रेस नहीं है, और यह बग नहीं है। state: present का मतलब है “इसे ऐसा दिखाओ”। state: new का मतलब है “मुझे एक नया दो”, हर एक बार, और इसने ठीक यही किया: दो रन के बाद एक इंटरफ़ेस पर दो एड्रेस।
जब आप सच में कुछ नया provision कर रहे हों तब यह ठीक है, और अगर आप इसे रोज़ रात चलने वाले किसी जॉब में डाल दें तो यह चुपचाप एक prefix खा जाएगा। एक बार allocate कीजिए और नतीजा रिकॉर्ड कीजिए, या जो एड्रेस आपके पास पहले से है उसके साथ state: present इस्तेमाल कीजिए। मॉड्यूल वही कर रहा है जो आपने कहा। सवाल यह है कि क्या आपने वही कहा जो आपका मतलब था।
बात सिर्फ़ Ansible की नहीं है
Collection पर ध्यान इसलिए जाता है क्योंकि ज़्यादातर नेटवर्क टीमें पहले से Ansible पर हैं, लेकिन असली प्रोडक्ट API है और बहुत सारी चीज़ें उसे बोलती हैं।
| चीज़ | यह क्या है | लाइसेंस |
|---|---|---|
pynetbox | वह Python क्लाइंट जिसे collection खुद इस्तेमाल करता है | Apache 2.0 |
terraform-provider-netbox | NetBox ऑब्जेक्ट्स को Terraform resources की तरह मैनेज करना, e-breuninger द्वारा सक्रिय रूप से मेंटेन | MPL 2.0 |
nornir_netbox | Nornir इन्वेंटरी के रूप में NetBox, उन लोगों के लिए जो YAML के बजाय Python करते हैं | Apache 2.0 |
| Prometheus SD | Prometheus को उसके scrape targets NetBox से देता है | MIT |
go-netbox | एक Go क्लाइंट, हालाँकि मई 2025 के बाद से इसे छुआ नहीं गया | रिपॉज़िटरी देखिए |
| Diode | discover किया गया डेटा अंदर धकेलने के लिए NetBox Labs की अपनी ingestion pipeline | NetBox Limited Use |
जो पहले से इस तरह इंफ़्रास्ट्रक्चर मैनेज कर रहा है, उसके लिए Terraform वाली एंट्री दिलचस्प है, क्योंकि यह एक ही plan से क्लाउड resource और उसे दर्ज करने वाला NetBox रिकॉर्ड दोनों बनाने देती है, दूसरा आधा हिस्सा किसी की याददाश्त पर छोड़ने के बजाय।15
Diode पर वही लाइसेंस है जो Branching और Custom Objects पर है, तो उस पर कुछ बनाने से पहले वही पढ़ाई लागू होती है।
वह दोपहर असल में क्या खरीदती है
ऊपर का सब कुछ मुझे एक मशीन पर एक दिन में लगा, और उस दिन का ज़्यादातर हिस्सा डेटा भरने में गया ताकि स्क्रीनों में कुछ हो। इंस्टॉल दोनों तरह से बीस मिनट का है। फ़ैसले ही असली हिस्सा हैं और वे सब पहले घंटे में हो जाते हैं: सबसे पहले tenants, डिवाइसों से पहले device types, नंबर किट पर नहीं बल्कि टाइप्स पर।
इसके बदले आपको जो मिलता है वह डॉक्यूमेंटेशन नहीं है। यह फ़र्क कोई तब तक नहीं करता जब तक उसके पास दोनों न रहे हों: डॉक्यूमेंटेशन वह चीज़ है जिसे आप लिखते हैं और फिर मेंटेन करना बंद कर देते हैं। आपको मिलता है एक डेटाबेस जो विरोधाभास रखने से मना करता है: यह आपको एक रैक यूनिट में दो चीज़ें, या किसी दूसरी साइट की location में एक रैक, या ऐसे टाइप पर डिवाइस जो मौजूद ही नहीं, नहीं रखने देगा। इनमें से हर इनकार एक बहस है जो आप छह महीने बाद नहीं कर रहे होंगे।
और यह आपको वे बातें बताएगा जो किसी ने पूछी नहीं। वह कैबिनेट किट से 28.6% भरी है और पावर से 90.7%। उसे ढूँढने कोई नहीं निकला था। वह एक बार device type पर wattage डालने से सामने आई, और यही फ़र्क है अगला ऑर्डर वहाँ रैक करने और कठिन तरीके से पता लगाने के बीच।
ईमानदार चेतावनी वही है जो हर source of truth के साथ होती है। यह उतना ही कीमती है जितना इसे सही रखने में आपका खर्च होता है, और इसका इकलौता रूप जो किसी व्यस्त तिमाही में बचता है वह है जिसमें डेटा गलत होने पर कुछ दिखाई देने लायक तरीके से टूटता है। अपनी मॉनिटरिंग, अपनी provisioning या अपने फ़ायरवॉल नियमों को इससे पढ़ने के लिए जोड़िए, और एक गलत एंट्री वह डॉक्यूमेंटेशन समस्या नहीं रह जाती जिस पर कोई कभी पहुँचेगा। वह किसी मंगलवार सुबह साढ़े नौ बजे का outage बन जाती है, जिस पर किसी का नाम होता है। यह एक कीमत जैसा लगता है। यही पूरा तंत्र है।
इसके लिए कोई आपको धन्यवाद भी नहीं देगा। सही रिकॉर्ड इस रूप में दिखता है: वह माइग्रेशन जिसमें एक तिमाही के बजाय एक पखवाड़ा लगा, वह ऑडिट जिसमें एक दोपहर लगी, वह कस्टमर जिसे फ़ोन पर सीधा जवाब मिला। इनमें से कुछ भी किसी रिपोर्ट पर आपके नाम के आगे नहीं आता।
फिर भी कीजिए। विकल्प है एक ऐसा बिज़नेस जो खुद का वर्णन नहीं कर सकता, और जो बिज़नेस खुद का वर्णन नहीं कर सकता वह चलाया नहीं जा रहा। उसे याद रखा जा रहा है, हर साल कम लोगों द्वारा।
NetBox, Introduction — “Today, the open source project is stewarded by NetBox Labs and a team of volunteer maintainers”, और 2015 में DigitalOcean पर शुरुआत, जून 2016 में open source हुआ। ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎
NetBox, LICENSE.txt — Apache License 2.0, copyright DigitalOcean, LLC। शुरुआत और देखरेख the introduction से। ↩︎ ↩︎
Nautobot v1.0.0 release notes — “a divergent fork of NetBox 2.10”, 26 अप्रैल 2021 को प्रकाशित, और NetBox 2.10 के मुकाबले इसमें जो जोड़ा गया उसकी सूची। ↩︎ ↩︎
Network to Code, “Why Did Network to Code Fork NetBox?”, 25 फ़रवरी 2021 — SLA और long-term support का तर्क, दृष्टिकोण का अलग होना, और “the NetBox project team suggested that we should consider forking”। ↩︎
NetBox Labs की स्थापना 2023 में IBM द्वारा NS1 के अधिग्रहण के बाद उससे अलग होकर हुई, सह-संस्थापक NetBox के लीड मेंटेनर Jeremy Stretch हैं, और इसने अप्रैल 2023 में $20m Series A की घोषणा की: NetBox Labs, “Let’s Go: Announcing NetBox Labs” और the Series A announcement। ↩︎
NetBox Labs, NetBox Enterprise — self-managed कमर्शियल edition, “24/7 expert assistance from the NetBox Labs team” के साथ; NetBox Cloud होस्ट किया गया विकल्प है। खास SLA शर्तें उस पेज पर प्रकाशित नहीं हैं। ↩︎
दोनों प्रोजेक्ट के star और fork की गिनती, रिलीज़ की तारीखें और लाइसेंस 30 सितंबर 2026 को GitHub API से पढ़े गए: netbox-community/netbox और nautobot/nautobot। Nautobot की समानांतर 3.2.x और 2.4.x रिलीज़ दोनों 28 सितंबर 2026 की तारीख की हैं। ↩︎
netbox-community/netbox-docker — कम्युनिटी का कंटेनर स्टैक, Apache 2.0। ↩︎
NetBox, Installation — समर्थित वर्शनों की टेबल, और बढ़ी हुई PostgreSQL और Redis न्यूनतम ज़रूरतों के लिए the v4.7 release notes। वर्शन और edition
netbox/release.yamlसे पढ़े गए। ↩︎NetBox Limited Use License 1.0 — netbox-custom-objects पर, और हूबहू वैसा ही netbox-branching पर। दोनों उद्धृत धाराएँ शब्दशः हैं। ↩︎
NetBox, HTTP Server installation, “What’s Next?” — “Some of the most popular plugins include” NetBox Branching, NetBox Custom Objects, NetBox DNS और NetBox BGP, लाइसेंस शर्तों के किसी ज़िक्र के बिना। ↩︎
NetBox, Data Validation configuration —
FIELD_CHOICES, और वह plus-sign suffix जो बदलने के बजाय बढ़ाता है: “To replace the available choices, specify the app, model, and field name separated by dots … To extend the available choices, append a plus sign”। ↩︎netboxlabs/netbox-custom-objects documentation — “Deleting a Custom Object Type drops an entire database table and should be done with caution.” ↩︎
netbox.netbox on Ansible Galaxy और netbox-community/ansible_modules — वर्शन 3.23.0, GPL-3.0, 91 मॉड्यूल और साथ में
nb_inventoryinventory प्लगइन। डाउनलोड की गिनती 30 सितंबर 2026 को Galaxy से पढ़ी गई। दिखाया गया सब कुछ ansible-core 2.21.4 और pynetbox 7.8.0 के साथ चलाया गया। ↩︎लाइसेंस, गतिविधि और star की गिनती 30 सितंबर 2026 को हर प्रोजेक्ट से पढ़ी गई: pynetbox (Apache 2.0), terraform-provider-netbox (MPL 2.0, Terraform registry पर v6.0.0-rc.1), nornir_netbox (Apache 2.0), netbox-plugin-prometheus-sd (MIT), go-netbox (आखिरी push 9 मई 2025) और Diode, जिस पर Branching और Custom Objects वाला ही NetBox Limited Use License 1.0 है। ↩︎