🍹 ⛽️ 😃 लिनक्स नेमस्पेस में गहरी डुबकी 🎽 👩🏾‍🤝‍👩🏻 🌽

पोस्ट की इस श्रृंखला में, हम कंटेनर में मुख्य सामग्रियों में से एक पर विचार करेंगे - नाम स्थान। इस प्रक्रिया में, हम docker run का एक सरल क्लोन बनाएंगे - हमारा अपना प्रोग्राम जो इनपुट पर कमांड (इसके तर्कों के साथ, यदि कोई हो) को ले जाएगा और इसके निष्पादन के लिए कंटेनर का विस्तार करेगा, तो बाकी सिस्टम से अलग, आप कैसे निष्पादित करेंगे; एक छवि से docker run लिए docker run ।

नाम स्थान क्या है?

लिनक्स नेमस्पेस ऑपरेटिंग सिस्टम में संसाधनों का एक अमूर्त हिस्सा है। हम एक बॉक्स के रूप में नामस्थान के बारे में सोच सकते हैं। इस बॉक्स में सिस्टम संसाधन होते हैं जो बॉक्स के प्रकार (नाम स्थान) पर निर्भर करते हैं। वर्तमान में सात प्रकार के नामस्थान हैं: Cgroups, IPC, Network, Mount, PID, User, UTS।

उदाहरण के लिए, नेटवर्क नेमस्पेस में नेटवर्क से संबंधित सिस्टम संसाधन जैसे कि नेटवर्क इंटरफेस (जैसे wlan0 , eth0 ), राउटिंग टेबल आदि शामिल हैं। माउंट नेमस्पेस में सिस्टम में फाइलें और निर्देशिकाएं शामिल हैं, पीआईडी में प्रोसेस आईडी शामिल हैं, और इसी तरह। । इस प्रकार, नेटवर्क नेमस्पेस ए और बी के दो उदाहरणों (हमारे सादृश्य में एक ही प्रकार के दो बक्से) में अलग-अलग संसाधन हो सकते हैं - शायद A में wlan0 होता है, जबकि B में eth0 और राउटिंग टेबल की एक अलग कॉपी होती है।

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

यह किस लिए है?

बिल्कुल कुछ भी नहीं ... बिल्कुल, मैं तो मजाक कर रहा था। बक्से के महान गुणों में से एक यह है कि आप बॉक्स से चीजों को जोड़ और हटा सकते हैं और इससे अन्य बक्से की सामग्री प्रभावित नहीं होगी। नामस्थान के साथ भी यही विचार है - P प्रक्रिया "पागल हो सकती है" और sudo rm –rf / निष्पादित करें, लेकिन किसी अन्य माउंट नामस्थान से संबंधित Q प्रक्रिया प्रभावित नहीं होगी, क्योंकि वे इन फ़ाइलों की अलग-अलग प्रतियों का उपयोग करते हैं।

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

प्रतिबंध एक चिंता का विषय है

हम उन नामस्थानों को देख सकते हैं जिनसे प्रक्रिया संबंधित है! आमतौर पर लिनक्स के लिए, वे प्रोसेस आईडी $pid साथ इस प्रक्रिया की /proc/$pid/ns निर्देशिका में फाइल के रूप में दिखाई देते हैं:

 $ ls -l /proc/$$/ns total 0 lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 cgroup -> cgroup:[4026531835] lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 ipc -> ipc:[4026531839] lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 mnt -> mnt:[4026531840] lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 net -> net:[4026531957] lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 pid -> pid:[4026531836] lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 user -> user:[4026531837] lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 uts -> uts:[4026531838]

आप एक और टर्मिनल खोल सकते हैं, एक ही कमांड निष्पादित कर सकते हैं और यह आपको एक ही परिणाम देना चाहिए। ऐसा इसलिए है, जैसा कि हमने पहले उल्लेख किया है, प्रक्रिया एक निश्चित नामस्थान (नामस्थान) से संबंधित होनी चाहिए और जब तक हम स्पष्ट रूप से निर्दिष्ट नहीं करते कि कौन सा है, लिनक्स डिफ़ॉल्ट रूप से इसे नामस्थान में जोड़ता है।

आइए इसमें थोड़ा सा जुड़ जाएं। दूसरे टर्मिनल में, हम कुछ इस तरह से कर सकते हैं:

 $ hostname iffy $ sudo unshare -u bash $ ls -l /proc/$$/ns lrwxrwxrwx 1 root root 0 May 18 13:04 cgroup -> cgroup:[4026531835] lrwxrwxrwx 1 root root 0 May 18 13:04 ipc -> ipc:[4026531839] lrwxrwxrwx 1 root root 0 May 18 13:04 mnt -> mnt:[4026531840] lrwxrwxrwx 1 root root 0 May 18 13:04 net -> net:[4026531957] lrwxrwxrwx 1 root root 0 May 18 13:04 pid -> pid:[4026531836] lrwxrwxrwx 1 root root 0 May 18 13:04 user -> user:[4026531837] lrwxrwxrwx 1 root root 0 May 18 13:04 uts -> uts:[4026532474] $ hostname iffy $ hostname coke $ hostname coke

unshare कमांड नए नेमस्पेस में प्रोग्राम (वैकल्पिक) लॉन्च करता है। -u ध्वज उसे नए यूटीएस नामस्थान में bash चलाने के लिए कहता है। ध्यान दें कि हमारी नई bash प्रक्रिया एक और uts फाइल की ओर uts है, जबकि बाकी सभी समान रहती हैं।

नए नामस्थान बनाने के लिए आमतौर पर सुपरसुसर पहुंच की आवश्यकता होती है। unshare , हम मान लेंगे कि दोनों और हमारे कार्यान्वयन को sudo का उपयोग करके किया जाता है ।

जो हमने अभी किया है, उसका एक परिणाम यह है कि अब हम सिस्टम होस्टनाम को अपनी नई बैश प्रक्रिया से बदल सकते हैं और यह सिस्टम में किसी अन्य प्रक्रिया को प्रभावित नहीं करेगा। आप पहले टर्मिनल में hostname चलाकर इसे सत्यापित कर सकते हैं और यह देखते हुए कि होस्टनाम वहां नहीं बदला है।

लेकिन क्या, उदाहरण के लिए, एक कंटेनर है?

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

उदाहरण के लिए, जब आप docker run --net=host redis टाइप करते हैं, तो आप जो कुछ भी करते हैं, उसे बताता है कि redis प्रक्रिया के लिए नया नेटवर्क नेमस्पेस नहीं बनाया है। और, जैसा कि हमने देखा है, लिनक्स इस प्रक्रिया को किसी अन्य नियमित प्रक्रिया की तरह डिफ़ॉल्ट नेटवर्क नामस्थान में एक भागीदार के रूप में जोड़ देगा। इस प्रकार, एक नेटवर्क बिंदु से, रेडिस प्रक्रिया बिल्कुल बाकी सभी के समान है। यह न केवल एक नेटवर्क कॉन्फ़िगरेशन विकल्प है, docker run आपको अधिकांश मौजूदा नामस्थानों के लिए इस तरह के बदलाव करने की अनुमति देता है। यह सवाल है, एक कंटेनर क्या है? क्या एक कंटेनर है जो एक प्रक्रिया का उपयोग करता है जो सभी का उपयोग करता है लेकिन सामान्य नामस्थान में से एक है? ¯ \ _ (ツ) _ / containers आमतौर पर, कंटेनर नेमस्पेस के माध्यम से प्राप्त अलगाव की अवधारणा के साथ आते हैं: नामस्थान और संसाधनों की संख्या जितनी कम हो, प्रक्रिया दूसरों के साथ साझा करती है, उतना ही यह अलग-थलग है और यह सब वास्तव में मायने रखता है।

sequestering

इस पोस्ट के शेष भाग में, हम अपने कार्यक्रम की नींव रखेंगे, जिसे हम isolate कहेंगे। isolate कमांड को तर्क के रूप में लेता है और इसे एक नई प्रक्रिया में शुरू करता है, बाकी सिस्टम से अलग किया जाता है और अपने स्वयं के नामस्थानों द्वारा सीमित किया जाता है। निम्नलिखित पदों में, हम अलग-अलग नामस्थानों के लिए प्रक्रिया कमांड के लिए समर्थन जोड़कर देखेंगे जो isolate शुरू होती है।

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

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

पदों के कोड अतिभार से बचने के लिए, हम सहायक कार्यों के रूप में ऐसी चीजों को शामिल नहीं करेंगे जो कार्यान्वयन को समझने के लिए आवश्यक नहीं हैं। आप पूर्ण स्रोत कोड यहाँ Github पर पा सकते हैं।

कार्यान्वयन

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

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

हमें तीन चीजें करने की जरूरत है:

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

यहाँ बुनियादी प्रक्रिया है:

 int main(int argc, char **argv) { struct params params; memset(&params, 0, sizeof(struct params)); parse_args(argc, argv, &params); //         . if (pipe(params.fd) < 0) die("Failed to create pipe: %m"); //   . int clone_flags = SIGCHLD | CLONE_NEWUTS ; int cmd_pid = clone(cmd_exec, cmd_stack + STACKSIZE, clone_flags, &params); if (cmd_pid < 0) die("Failed to clone: %m\n"); //      . int pipe = params.fd[1]; //      namespace ... //   ,     . if (write(pipe, "OK", 2) != 2) die("Failed to write to pipe: %m"); if (close(pipe)) die("Failed to close pipe: %m"); if (waitpid(cmd_pid, NULL, 0) == -1) die("Failed to wait pid %d: %m\n", cmd_pid); return 0; }

हमारे clone कॉल में पास होने वाले clone_flags ध्यान दें। देखें कि अपने नामस्थान में एक प्रक्रिया बनाना कितना आसान है? हम सभी को नामस्थान प्रकार ( CLONE_NEWUTS ध्वज UTS नामस्थान से मेल खाता है) के लिए एक ध्वज सेट करने की आवश्यकता है, और लिनक्स बाकी का ध्यान रखेगा।

अगला, कमांड प्रक्रिया शुरू होने से पहले एक संकेत की उम्मीद करती है:

 static int cmd_exec(void *arg) { //   cmd   isolate . if (prctl(PR_SET_PDEATHSIG, SIGKILL)) die("cannot PR_SET_PDEATHSIG for child process: %m\n"); struct params *params = (struct params*) arg; //   ' '   . await_setup(params->fd[0]); char **argv = params->argv; char *cmd = argv[0]; printf("===========%s============\n", cmd); if (execvp(cmd, argv) == -1) die("Failed to exec %s: %m\n", cmd); die("¯\\_(ツ)_/¯"); return 1; }

अंत में, हम इसे चलाने का प्रयास कर सकते हैं:

 $ ./isolate sh ===========sh============ $ ls isolate isolate.c isolate.o Makefile $ hostname iffy $ hostname coke $ hostname coke #     ,

अब isolate एक कार्यक्रम की तुलना में थोड़ा अधिक है जो बस टीम पर हमला करता है (हमारे पास एक यूटीएस है जो हमारे लिए काम करता है)। अगली पोस्ट में, हम यूजर नेमस्पेस की जांच करके एक और कदम उठाएंगे और अपने खुद के यूजर नेमस्पेस में कमांड निष्पादित करेंगे। वहां हम देखेंगे कि हमें वास्तव में एक प्रयोग करने योग्य नाम स्थान रखने के लिए कुछ काम करने की आवश्यकता है जिसमें कमांड निष्पादित हो सकती है।