VPS का इतिहास: Mainframe से Cloud तक का सफर

आपका VPS कहाँ से आता है

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

1959 से 1961: time-sharing का आविष्कार क्यों हुआ

1950 के दशक में कंप्यूटर batch mode में चलते थे। आप अपने प्रोग्राम को cards पर punch करते थे, deck को operator को सौंपते थे और बाद में printout लेने के लिए वापस आते थे। एक गलत type किए गए character के कारण आपका पूरा दिन बर्बाद हो जाता था। मशीन व्यस्त रहती थी, जो कि मुख्य उद्देश्य था, क्योंकि IBM 7090 जैसी मशीन की कीमत लाखों डॉलर थी और उसके लिए प्रतीक्षा करने वाले लोगों के समय का मूल्य किसी invoice पर नहीं दिखता था।

जनवरी 1959 में John McCarthy ने MIT के एक memo में इसके विपरीत तर्क दिया। मशीन को व्यक्ति के लिए प्रतीक्षा करनी चाहिए। Christopher Strachey ने उसी वर्ष UNESCO के एक सम्मेलन में time-sharing के एक रूप का वर्णन किया, हालांकि उनका मतलब एक साथ कई लोगों के type करने के बजाय, अन्य jobs के चलने के दौरान एक programmer द्वारा debugging करने से था। 1961 में MIT के शताब्दी समारोह में बोलते हुए, McCarthy ने और आगे बढ़कर कहा: computing को एक public utility के रूप में बेचा जा सकता है, जिसे बिजली की तरह meter किया जा सके।

उस समय आपत्ति यह थी कि time-sharing से मशीन बर्बाद होती है। users के बीच switching करने में cycles खर्च होते हैं, और cycles ही सबसे महंगी चीज थी। यह आपत्ति सही थी, और बाद में इसका महत्व खत्म हो गया, क्योंकि साठ वर्षों तक cycle की कीमत गिरती रही जबकि मानव ध्यान के एक घंटे की कीमत कम नहीं हुई।

CTSS को किन चीजों का आविष्कार करना पड़ा

MIT Computation Center में Fernando Corbató के समूह ने इस बहस को सुलझाने के लिए Compatible Time-Sharing System (CTSS) बनाया। इसे पहली बार नवंबर 1961 में IBM 709 पर प्रदर्शित किया गया था, जो चार उपयोगकर्ताओं को सेवा दे रहा था और प्रत्येक उपयोगकर्ता के काम को उसकी अपनी magnetic tape drive पर swap कर रहा था। "Compatible" का अर्थ था कि मशीन अभी भी नीचे पुराने batch system को चला सकती थी, क्योंकि कोई भी ऐसा कंप्यूटर नहीं खरीदता जो केवल नया काम ही करे।

चार उपयोगकर्ता एक छोटी संख्या है। उन समस्याओं की सूची जिन्हें हल करना पड़ा, वह छोटी नहीं है, और यह वही सूची है जिस पर आपका kernel अभी काम कर रहा है। CTSS को एक scheduler की आवश्यकता थी, ताकि एक लंबा job बाकी सभी terminals को freeze न कर सके। इसे memory protection की आवश्यकता थी, ताकि एक crashing program पूरे सिस्टम के बजाय केवल एक उपयोगकर्ता को प्रभावित करे। इसे ऐसे storage की आवश्यकता थी जो logout के बाद भी सुरक्षित रहे, यही कारण है कि CTSS में उन पहले file systems में से एक था जिसे एक आधुनिक उपयोगकर्ता पहचान लेगा। और इसे passwords की आवश्यकता थी, ताकि एक उपयोगकर्ता दूसरे उपयोगकर्ता की files को न पढ़ सके।

उन भागों का नाम बदलें और आपके पास एक Linux box है। scheduler EEVDF है, जिसने Linux 6.6 में CFS की जगह ली। memory protection MMU (memory management unit) है जो प्रत्येक process को उसका अपना virtual address space देता है। logout के बाद सुरक्षित रहने वाला storage आपकी home directory है। password file को अभी भी /etc/passwd कहा जाता है।

Multics और कंप्यूटर यूटिलिटी

MIT का अगला सिस्टम वही यूटिलिटी था जिसका वर्णन McCarthy ने किया था। Project MAC की शुरुआत 1963 में हुई, अगस्त 1964 में General Electric GE-645 के लिए अनुबंध पर हस्ताक्षर किए गए, और 1965 में Multics के पहले शोध पत्र प्रकाशित हुए। इसका नाम ही इसके तर्क को स्पष्ट करता है: Multiplexed Information and Computing Service। सर्विस, यानी ऐसी चीज जिसे आप प्रति घंटे के हिसाब से खरीदते हैं।

Multics को योजना से कहीं अधिक समय लगा। प्रोटोटाइप GE-645 मशीनें जनवरी 1967 में MIT और Bell Labs पहुँचीं। Bell Labs अप्रैल 1969 में इस प्रोजेक्ट से अलग हो गया। Multics को 1 अक्टूबर 1969 को MIT Information Processing Center के ग्राहकों के लिए खोला गया, और इसके बाद यह इकतीस वर्षों तक प्रोडक्शन में चला। Halifax, Nova Scotia में Canadian Department of National Defence में स्थित अंतिम सक्रिय Multics सिस्टम को 30 अक्टूबर 2000 को बंद कर दिया गया।

Multics को अक्सर एक विफलता के रूप में दर्ज किया जाता है क्योंकि यह देर से आया और धीमा चला। शब्दावली कुछ और ही कहती है। इसने हमें डायरेक्टरी के अंदर डायरेक्टरी वाली पदानुक्रमित फाइल सिस्टम (hierarchical file system), प्रत्येक फाइल पर एक access control list, सेगमेंटेड वर्चुअल मेमोरी जिसने प्रोग्राम को फाइल को मेमोरी की तरह एड्रेस करने की सुविधा दी, और प्रोटेक्शन रिंग्स दीं जो कोड को उसकी विश्वसनीयता के आधार पर रैंक करती थीं। रिंग्स आज भी आपके सामने सिलिकॉन में मौजूद हैं। कर्नल के लिए Ring 0 और यूजर कोड के लिए Ring 3, Multics की शब्दावली है, और हार्डवेयर वर्चुअलाइजेशन ने बाद में हाइपरवाइजर के लिए Ring 0 के नीचे एक मोड जोड़ा, जिसे लोग अनौपचारिक रूप से Ring -1 कहते हैं।

Unix: एक ऐसी मशीन पर time-sharing जिसे आप खरीद सकते थे

Multics छोड़ने के बाद Ken Thompson के पास Bell Labs में ऐसा कोई system नहीं बचा जिसे वे इस्तेमाल करना चाहते थे। 1969 में उन्होंने एक बेकार पड़े PDP-7 पर बहुत छोटे स्तर से काम शुरू किया। पहला Unix Programmer's Manual नवंबर 1971 का है, जिस समय तक यह काम PDP-11 पर स्थानांतरित हो चुका था। 1973 में Thompson और Dennis Ritchie ने kernel को C में फिर से लिखा, ताकि system को बार-बार हाथ से लिखे बिना नए hardware पर चलाया जा सके।

यही कारण है कि आप Unix के वंशज में टाइप करते हैं, न कि Multics के वंशज में। Multics को उसी के लिए बने hardware की आवश्यकता थी। Unix उस हर चीज़ पर चल गया जो सस्ता और उपलब्ध था, और यही निर्णायक विशेषता साबित हुई।

Ritchie और Thompson द्वारा लिखित "The UNIX Time-Sharing System" जुलाई 1974 में Communications of the ACM में प्रकाशित हुआ था। यह शोध-पत्र आपके VPS का वर्णन करता है: processes, एक पदानुक्रमित (hierarchical) file system, files जो साधारण byte streams हैं, fork, permission bits वाले users और groups, और एक shell जो kernel का हिस्सा होने के बजाय एक सामान्य program है। बावन साल बाद भी उस interface का विस्तार हुआ है, उसे कभी बदला नहीं गया।

क्या mainframes वास्तव में 1972 में virtual machines चलाते थे?

हाँ, और यह कहानी का वह हिस्सा है जिसे ज्यादातर लोग नजरअंदाज कर देते हैं। जहाँ MIT ने Multics बनाया, वहीं IBM के Cambridge Scientific Center ने उसी लक्ष्य को दूसरे दृष्टिकोण से हासिल किया। एक operating system द्वारा कई users को सेवा देने के बजाय, Robert Creasy और Les Comeau ने एक control program बनाया जो प्रत्येक user को एक पूर्ण simulated computer देता था। CP-40 जनवरी 1967 में production में आया। प्रत्येक user को एक virtual System/360 मिला और उन्होंने उसके भीतर एक छोटा single-user operating system, CMS, चलाया।

CP-40, 1968 में System/360-67 पर CP-67 बन गया, और IBM ने 2 अगस्त 1972 को VM/370 की घोषणा की। यह एक commercial hypervisor था, जिसे चौवन साल पहले भुगतान करने वाले ग्राहकों को बेचा गया था। एक control program वास्तविक hardware को multiplex करता था, और guest operating systems उन virtual machines के भीतर बिना किसी बदलाव के चलते थे जो यह मानती थीं कि वे ही उस मशीन की मालिक हैं।

इसका सिद्धांत दो साल बाद आया, Communications of the ACM के उसी जुलाई 1974 के अंक में जिसमें Unix का शोध पत्र प्रकाशित हुआ था। Gerald Popek और Robert Goldberg के "Formal Requirements for Virtualizable Third Generation Architectures" ने यह निर्धारित किया कि एक processor को virtualisable होने के लिए क्या करना चाहिए। इसका मुख्य नियम संक्षिप्त है। हर वह instruction जो मशीन की स्थिति को पढ़ या बदल सकता है, उसे तब trap करना चाहिए जब कोई guest उसे kernel mode के बाहर execute करे, ताकि hypervisor नियंत्रण ले सके और उस guest के अपने निजी version के साथ उत्तर दे सके। इसे trap and emulate कहा जाता है। IBM का hardware इस नियम का पालन करता था।

मिनिकंप्यूटर ने मॉडल को कैसे तोड़ा

DEC ने 22 March 1965 को लगभग $18,000 (1965 के डॉलर मूल्य के अनुसार) में PDP-8 पेश किया। यह $20,000 से कम कीमत वाला पहला मिनिकंप्यूटर था और इसकी 50,000 से अधिक इकाइयाँ बिकीं। इसके बाद माइक्रोप्रोसेसर ने कीमतों को और कम कर दिया। जब कोई विभाग अपना खुद का मशीन खरीद सकता था, और बाद में जब कोई व्यक्ति ऐसा कर सकता था, तो एक केंद्रीय कंप्यूटर को साझा करना एक ऐसी समस्या लगने लगी जिसे हल करने की अब आवश्यकता नहीं थी। 1980 और 1990 के दशक के दौरान कंप्यूटिंग डेस्क तक और छोटे x86 सर्वर्स के रैक में स्थानांतरित हो गई।

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

x86 को वर्चुअलाइज करना इतना कठिन क्यों था?

x86 ने Popek और Goldberg के नियम का उल्लंघन किया था। अगस्त 2000 में 9वें USENIX Security Symposium में, John Scott Robin और Cynthia Irvine ने Pentium instruction set का विश्लेषण किया। उन्होंने सत्रह ऐसे निर्देश पाए जो user-mode कोड द्वारा चलाए जाने पर बिना किसी fault के privileged state को पढ़ते या बदलते हैं। popf इसका मानक उदाहरण है। यदि इसे user mode में चलाया जाए, तो प्रोसेसर चुपचाप उन bits को अनदेखा कर देता है जिन्हें प्रोग्राम सेट नहीं कर सकता, बजाय इसके कि वह trap उत्पन्न करे। इस कारण, trap and emulate पर आधारित hypervisor को कभी पता ही नहीं चलता कि guest ने ऐसा करने का प्रयास किया था।

हार्डवेयर में सुधार होने से पहले दो समाधान सामने आए। Stanford के Disco शोध से 1998 में स्थापित VMware ने guest kernel कोड का निरीक्षण किया और निष्पादन से पहले कठिन निर्देशों को फिर से लिखा; इस तकनीक को binary translation कहा जाता है। University of Cambridge Computer Laboratory के Xen ने इसके बजाय guest को ही बदल दिया। अक्टूबर 2003 में SOSP में प्रस्तुत "Xen and the Art of Virtualization" शोध पत्र ने paravirtualisation का वर्णन किया: एक संशोधित guest kernel उन निर्देशों को चलाने के बजाय जिन्हें hypervisor intercept नहीं कर सकता, जानबूझकर hypervisor को कॉल करता है।

फिर हार्डवेयर को ठीक किया गया, ठीक वैसे ही जैसे IBM ने 1960 के दशक में किया था। Intel ने 14 नवंबर 2005 को दो Pentium 4 मॉडलों पर VT-x जारी किया और AMD ने मई 2006 में AMD-V जारी किया। दोनों ने guest kernel के नीचे एक नया प्रोसेसर मोड जोड़ा। इससे guest अपना kernel पूरी गति से चला सकता है, जबकि hypervisor उन घटनाओं पर नियंत्रण रखता है जिन्हें वह ट्रैक करना चाहता है। इसने hypervisor को इतना छोटा बना दिया कि वह एक सामान्य operating system के भीतर रह सके। Qumranet में Avi Kivity के KVM ने ठीक यही किया: इसने Linux kernel को ही hypervisor में बदल दिया। KVM को फरवरी 2007 में जारी Linux 2.6.20 के लिए मर्ज किया गया था, और आज अधिकांश VPS hosts इसी का उपयोग करते हैं।

VPS का नाम कैसे पड़ा

2000 के दशक की शुरुआत में दो धाराएं एक साथ मिलीं। पहली x86 पर पूर्ण virtual machine थी, जो एक guest के रूप में अपना kernel boot करती थी। दूसरी operating-system-level virtualisation थी: एक साझा Linux kernel को अलग-अलग वातावरणों में विभाजित करना, जहाँ प्रत्येक का अपना root user और अपनी process table होती थी। Linux-VServer और SWsoft का Virtuozzo दोनों 2001 में आए, और SWsoft ने 2005 में Virtuozzo के एक हिस्से को open-source OpenVZ के रूप में जारी किया। "virtual private server" वाक्यांश परिवार की उसी शाखा से आया है, जिसे virtual private network के सादृश्य पर बनाया गया था।

Amazon ने इस किराए की सेवा को एक API call में बदल दिया। S3 को 14 March 2006 को लॉन्च किया गया, और EC2 को 25 August 2006 को एक सीमित public beta के रूप में खोला गया, जिसमें Xen पर चलने वाला एक ही instance type था। compute खरीदना अब किसी service bureau के साथ अनुबंध नहीं रहा, बल्कि एक ऐसा अनुरोध बन गया जो एक मिनट में पूरा हो जाता है।

दोनों धाराएं आज भी मौजूद हैं, और यह विभाजन अभी भी तय करता है कि आप किराए पर लिए गए सर्वर के साथ क्या कर सकते हैं। एक KVM VPS अपना kernel boot करता है, इसलिए आप kernel modules लोड कर सकते हैं और यहाँ तक कि अपने VPS के अंदर एक hypervisor भी चला सकते हैं। container-आधारित plan host kernel को साझा करता है और ऐसा नहीं कर सकता। pricing page पर लिखी उस एक पंक्ति के पीछे साठ वर्षों का इतिहास है, इसीलिए यह समझने में समझदारी है कि VPS, VM और VPC में क्या अंतर है इससे पहले कि आप किसी एक को चुनें।

Mainframe से आपके VPS तक क्या बदला और क्या नहीं बदला

चार चीजें बदली हैं। मशीन आपकी इमारत में नहीं है। टर्मिनल अब फर्नीचर का एक टुकड़ा होने के बजाय एक प्रोग्राम है। आप जो यूनिट किराए पर लेते हैं, वह किसी और के ऑपरेटिंग सिस्टम पर केवल एक अकाउंट नहीं, बल्कि अपने स्वयं के kernel वाला एक पूरा कंप्यूटर है। और कीमत इतनी कम हो गई है कि खरीदारी अब एक लंबी खरीद प्रक्रिया (procurement process) के बजाय केवल एक कार्ड पेमेंट है।

कार्यप्रणाली (mechanism) बिल्कुल भी नहीं बदली है।

• आपका ssh session एक time-sharing टर्मिनल है। आपको एक login और एक shell मिलता है, और एक scheduler तय करता है कि आपका process कब चलेगा।
• Isolation अभी भी hardware द्वारा लागू की जाती है। MMU और प्रोसेसर के privilege levels वही काम करते हैं, ठीक वैसे ही जैसे 1967 में CP-40 को उनकी आवश्यकता थी।
• आपसे अभी भी मशीन के एक हिस्से के लिए बीते हुए समय के आधार पर शुल्क लिया जाता है, ठीक वैसे ही जैसे service bureaus connect hours के लिए बिल भेजते थे।
• आप अभी भी अन्य tenants का प्रभाव महसूस करते हैं। जब एक host oversubscribed होता है, तो आपका guest एक physical CPU के लिए प्रतीक्षा करता है, और Linux उस प्रतीक्षा को noisy neighbour से CPU steal time के रूप में रिपोर्ट करता है।

यह अंतिम बिंदु पूरे इतिहास का ईमानदार सारांश है। एक मशीन साझा करना एक समझौता है। 1961 में इसे इसलिए स्वीकार किया गया क्योंकि कंप्यूटर की कीमत लोगों से अधिक थी, और 2026 में इसे इसलिए स्वीकार किया जाता है क्योंकि अपनी क्षमता के दस प्रतिशत पर चलने वाला सर्वर पैसे की बर्बादी है। यदि आप उस समझौते में operator की तरफ रहना पसंद करते हैं, तो अपने स्वयं के hardware पर Proxmox चलाना आपको hypervisor और operator की समस्याएं एक साथ देता है।

अनुपात (ratio) को ध्यान में रखें। CTSS ने एक ऐसी मशीन पर चार उपयोगकर्ताओं को सेवा दी, जिसकी कीमत 1961 के लाखों डॉलर थी और जो एक पूरे कमरे में आती थी। 2026 में कुछ डॉलर प्रति माह पर मिलने वाला आपका VPS, Corbató की टीम द्वारा ration किए गए कंप्यूटर से कहीं बेहतर है, और यह पूरी तरह आपके पास है। आप इसे किराए पर ले पा रहे हैं क्योंकि 65 साल पुराना एक विचार अंततः सस्ते hardware के साथ मिल गया है। यदि आप यह तय कर रहे हैं कि इस पर क्या चलाना है, तो एक VPS वास्तव में आपको क्या देता है से शुरुआत करें और फिर लोग इस पर क्या चलाते हैं देखें।

FAQ

पहला time-sharing कंप्यूटर सिस्टम कौन सा था?

CTSS, यानी Compatible Time-Sharing System, जिसे MIT Computation Center में Fernando Corbató के समूह ने बनाया था। इसका पहला प्रदर्शन नवंबर 1961 में एक IBM 709 पर किया गया था और यह चार users को सेवा देता था, जिनमें से प्रत्येक को अलग tape drive पर swap किया जाता था। पूरे समुदाय के लिए पहली time-sharing सेवा Dartmouth Time-Sharing System थी: 1 मई 1964 को, John Kemeny और एक छात्र प्रोग्रामर ने दो terminals पर एक साथ BASIC programs चलाए और दोनों को सही उत्तर प्राप्त हुए।

क्या virtual machines वास्तव में 1960 के दशक में खोजी गई थीं?

हाँ। IBM के Cambridge Scientific Center ने जनवरी 1967 में CP-40 को production में उतारा, जिससे प्रत्येक user को एक पूर्ण virtual System/360 मिला, जिसके अंदर CMS operating system चल रहा था। इसके बाद 1968 में System/360-67 पर CP-67 आया, और IBM ने 2 अगस्त 1972 को VM/370 की घोषणा की। ये वास्तविक hypervisors थे जो unmodified guest operating systems को चलाते थे और व्यावसायिक रूप से बेचे जाते थे, x86 hardware के ऐसा करने में सक्षम होने से कई दशक पहले।

mainframes की तुलना में x86 को virtualise करना कठिन क्यों था?

Popek और Goldberg का 1974 का नियम कहता है कि हर वह instruction जो machine state को पढ़ या बदल सकता है, उसे तब trap करना चाहिए जब कोई guest उसे kernel mode के बाहर चलाए। x86 ने इस नियम को तोड़ा। Robin और Irvine ने सत्रह ऐसे Pentium instructions गिने जो trap होने के बजाय user mode में चुपचाप fail हो जाते हैं, इसलिए एक क्लासिक trap-and-emulate hypervisor उन्हें कभी देख नहीं पाता, और popf इसका सामान्य उदाहरण है। VMware ने binary translation के साथ और Xen ने paravirtualisation के साथ इसका समाधान निकाला, जब तक कि नवंबर 2005 में Intel VT-x और मई 2006 में AMD-V ने hypervisor के लिए एक hardware mode नहीं जोड़ दिया।

क्या VPS किराए पर लेना time-sharing account रखने जैसा ही है?

billing model और isolation की समस्या एक ही है। इकाई (unit) अलग है। एक time-sharing user को एक ऐसे operating system पर account मिलता था जिसे बाकी सभी के साथ साझा किया जाता था, इसलिए administrator कंप्यूटर सेंटर का कोई व्यक्ति होता था। एक KVM VPS आपको अपने kernel और अपने root account के साथ एक virtual machine देता है, इसलिए administrator आप स्वयं होते हैं। एक container-based VPS इन दोनों के बीच में आता है, क्योंकि यह host kernel को साझा करता है जबकि आपको अपने environment के अंदर root access भी देता है।