डिस्क रहित नेटवर्क बूट और afterlife

कहानी

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

सिद्धांत

वास्तव में, सिस्टम को बूट करने के लिए, इसे 3 घटकों की आवश्यकता होती है - कर्नेल, इनट्राम्राम्स का प्रारंभिक वातावरण और रूट निर्देशिका जिसमें सिस्टम काम करेगा।

अभ्यास

Ubuntu सटीक के साथ कार द्वारा सभी कार्य किए जाते हैं।

PXE

सबसे पहले, PXE कॉन्फ़िगर करें। इस विषय पर बहुत सारे मैनुअल हैं, इसलिए मैं केवल सार बताऊंगा।
हम आपके पसंदीदा dhcp सर्वर को रखते हैं, उदाहरण के लिए, isc-dhcp-server, जो मशीनों को आईपी पते वितरित करेगा और pxelinux.0 फ़ाइल को पथ इंगित करेगा जो tftp सर्वर (tftp-ht या atftp) देगा।

aptitude install isc-dhcp-server tftpd-hpa 

Dhcp सर्वर कॉन्फिग का उदाहरण। उदाहरण में, pxe सर्वर 10.0.0.1 पर स्थित है।

 option domain-name-servers 8.8.8.8; server-name "pxe"; subnet 10.0.0.0 netmask 255.255.255.0 { range dynamic-bootp 10.0.0.2 10.0.0.10; option subnet-mask 255.255.255.0; option routers 10.0.0.1; option root-path "10.0.0.1:/var/lib/tftpboot/"; filename "pxelinux.0"; } 

हम tftp सर्वर शुरू करते हैं (उबंटू में इसकी एक इनइट स्क्रिप्ट है, लेकिन यह संभावना है कि आपको इसे inetd / xinetd के माध्यम से भी चलाना होगा)।
हम प्रदर्शन की जांच करते हैं। हमने फ़ाइल को निर्देशिका / var / lib / tftpboot में रखा और tftp क्लाइंट के साथ खींचने का प्रयास किया।

 tftp 10.0.0.1 tftp> get pxelinux.0 

सिद्धांत रूप में, इससे कोई फर्क नहीं पड़ता कि आपको pxelinux.0 फ़ाइल कहाँ मिलती है, क्योंकि यह सिर्फ बूटलोडर है जिसमें हम स्थानांतरण करते हैं जिसे आगे लोड करने की आवश्यकता होती है।
आप बूटलोडर में एक सुंदर मेनू बना सकते हैं, लेकिन अब हमें इसकी आवश्यकता नहीं है, इसलिए मेरा pxelinux.cfg / default इस तरह दिखता है

 default vesamenu.c32 aprompt 1 timeout 2 label ubuntu 12.04 menu label Ubuntu precise kernel vmlinuz append initrd=initrd.img boot=ram rooturl=http://10.0.0.1/rootfs.squashfs ip=dhcp 

rootfs

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

 mkdir -p /mnt/rootfs debootstrap precise /mnt/rootfs/ http://mirror.yandex.ru/ubuntu/ chroot /mnt/rootfs /bin/bash aptitude install vim ... 

हमारे न्यूनतम सेट के साथ, सिस्टम 200 एमबी वजन का निकला।

initramfs

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

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

  mksquashfs /mnt/rootfs/ rootfs.squashfs -noappend -always-use-fragments du -hs rootfs.squashfs 92M rootfs.squashfs 

अधिक कुशल संपीड़न के लिए, आप-कॉम्पलेक्स प्रकार का उपयोग करके संपीड़न के प्रकार को सेट कर सकते हैं, gzip डिफ़ॉल्ट रूप से उपयोग किया जाता है।

अगला, आपको रूट इमेज लेने और रैम में डालने के लिए initramfs से init सिखाना होगा।

init initramfs एक sh स्क्रिप्ट है जो cmdline से विकल्पों को पार करती है, fts को mounts करती है, switch_root बनाती है और सिस्टम की मुख्य init प्रक्रिया शुरू करती है।
हम इसका उपयोग करेंगे और cmdline के लिए अपने विकल्प जोड़ेंगे। हम एक राम स्क्रिप्ट लिखते हैं जिसे बूट = रैम विकल्प सेट होने पर बुलाया जाएगा।

vim / usr / share / initramfs-tools / script / ram

 #!/bin/bash retry_nr=0 do_rammount() { log_begin_msg "Configuring networking" configure_networking log_end_msg log_begin_msg "Downloading rootfs image" mkdir -p /tmp/squashfs wget ${rooturl} -O /tmp/squashfs/rootfs.squashfs log_end_msg log_begin_msg "Mounting rootfs image to /mnt/squashfs" mkdir -p /mnt/squashfs mount -t squashfs -o loop /tmp/squashfs/rootfs.squashfs /mnt/squashfs log_end_msg log_begin_msg "Mounting tmpfs and copy rootfs image" mkdir -p ${rootmnt} mount -t tmpfs -o size=1G none ${rootmnt} cp -r -v /mnt/squashfs/* ${rootmnt} || exit 2 log_end_msg log_begin_msg "Umount squashfs" umount /mnt/squashfs || exit 2 log_end_msg } mountroot() { for x in $(cat /proc/cmdline); do case $x in rooturl=*) export rooturl=${x#rooturl=} ;; esac done log_begin_msg "Loading module squashfs" modprobe squashfs log_end_msg # For DHCP modprobe af_packet wait_for_udev 10 # Default delay is around 180s delay=${ROOTDELAY:-180} # loop until rammount succeeds do_rammount while [ ${retry_nr} -lt ${delay} ] && [ ! -e ${rootmnt}${init} ]; do log_begin_msg "Retrying rammount" /bin/sleep 1 do_rammount retry_nr=$(( ${retry_nr} + 1 )) log_end_msg done } 

रूटर्ल पैरामीटर के माध्यम से, आप यह निर्दिष्ट कर सकते हैं कि रूट fs इमेज कहां से डाउनलोड करें। स्क्वैश के साथ काम करने के लिए, आपको इसके मॉड्यूल को कर्नेल में लोड करना होगा। हम /etc/initramfs-tools/initramfs.conf BOOT = ram में इंगित करते हैं और initrfs का पुनर्निर्माण करते हैं

 mkinitramfs -o /var/lib/tftpboot/initrd.img 

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

इस उदाहरण में, हमने केवल छवि को संपीड़ित करने के लिए स्क्वाशफ़ का उपयोग किया, लेकिन हम स्क्वैश में रूट विभाजन को माउंट करने की कोशिश क्यों नहीं करते हैं और देखें कि क्या होता है? हम अपनी स्क्रिप्ट बदलते हैं, do_rammount () फ़ंक्शन में हम केवल बढ़ते स्क्वैश को छोड़ते हैं।

 do_rammount() { log_begin_msg "Configuring networking" configure_networking log_end_msg log_begin_msg "Downloading rootfs image" mkdir -p /tmp/squashfs wget ${rooturl} -O /tmp/squashfs/rootfs.squashfs log_end_msg log_begin_msg "Mounting rootfs image to /mnt/squashfs" mkdir -p /mnt/squashfs mount -t squashfs -o loop /tmp/squashfs/rootfs.squashfs ${rootmnt} log_end_msg } 

हम initramfs का पुनर्निर्माण करते हैं, चलाते हैं, देखते हैं। सिस्टम रो मोड में बूट करता है, लेकिन इसमें लगभग 180MB मेमोरी लगती है।
कुछ मामलों में, आरओ मोड में माउंटिंग अच्छा है, लेकिन यह हमें शोभा नहीं देता है, लेकिन हम भी रैम को ऐसे ही बर्बाद नहीं करना चाहते हैं। इसका हल Aufs की मदद से मिला।

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

  log_begin_msg "Loading module aufs" modprobe aufs log_end_msg 

और do_rammount () फ़ंक्शन निम्न रूप में घटाया गया है:

 do_rammount() { log_begin_msg "Configuring networking" configure_networking log_end_msg log_begin_msg "Downloading rootfs image" mkdir -p /tmp/squashfs wget ${rooturl} -O /tmp/squashfs/rootfs.squashfs log_end_msg log_begin_msg "Mounting rootfs image to /mnt/ro" mkdir -p /mnt/ro mount -t squashfs -o loop /tmp/squashfs/rootfs.squashfs /mnt/ro log_end_msg log_begin_msg "Mounting tmpfs to /mnt/rw" mkdir -p /mnt/rw mount -t tmpfs -o size=1G none /mnt/rw log_end_msg log_begin_msg "Mounting aufs to /mnt/aufs" mkdir -p /mnt/aufs mount -t aufs -o dirs=/mnt/rw=rw:/mnt/ro=ro aufs /mnt/aufs log_end_msg [ -d /mnt/aufs/mnt/ro ] || mkdir -p /mnt/aufs/mnt/ro [ -d /mnt/aufs/mnt/rw ] || mkdir -p /mnt/aufs/mnt/rw mount --move /mnt/ro /mnt/aufs/mnt/ro #  squashfs   aufs mount --move /mnt/rw /mnt/aufs/mnt/rw #   tmpfs  aufs mount --move /mnt/aufs ${rootmnt} #   aufs  ${rootmnt} } 

हम initramfs का पुनर्निर्माण करते हैं, चलाते हैं, देखते हैं। सिस्टम 181MB मेमोरी लेता है, जबकि हम इसे बदल सकते हैं, लिख सकते हैं, पढ़ सकते हैं। सभी परिवर्तन अलग-अलग / mnt / rw में संग्रहीत किए जाते हैं, और सिस्टम स्वयं / mnt / ro में संग्रहीत होता है।

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

उपरोक्त सभी विधियों में जीवन का अधिकार है। मुझे उम्मीद है कि यह जानकारी आपके लिए उपयोगी है, लेकिन आपकी टिप्पणियों को पढ़ना / सुनना मेरे लिए दिलचस्प होगा।
आपका ध्यान देने के लिए धन्यवाद।

संदर्भ

उबटन बूट राम को
स्क्वाशफ़ेफ़ होम पेज
PXE