VPS का इतिहास: Mainframe से Cloud तक का सफर
क्या आप जानते हैं कि आपका VPS 1960 के दशक की time-sharing तकनीक का आधुनिक रूप है? CTSS, Unix और KVM के विकास के माध्यम से समझें कि कैसे कंप्यूटिंग की यह बुनियादी समस्या आज भी कायम है।
आपका VPS कहाँ से आता है
मेनफ्रेम से लेकर क्लाउड तक कंप्यूटिंग का इतिहास एक विचार के सस्ते होने की कहानी है। वह विचार है टाइम-शेयरिंग: एक महंगी मशीन को एक ही समय में कई लोगों द्वारा इस्तेमाल करने देना, और उनमें से प्रत्येक को उसका एक निजी दृश्य प्रदान करना। इसका आविष्कार 1960 के आसपास हुआ था क्योंकि कंप्यूटर की कीमत उसे इस्तेमाल करने वाले लोगों से अधिक थी। आज आप जो VPS किराए पर लेते हैं, उसका हर हिस्सा उसी समस्या के लिए बनाया गया था: उपयोगकर्ताओं के बीच अलगाव, CPU समय आवंटित करने वाला शेड्यूलर, हाइपरवाइजर, और घंटों की गणना करने वाला बिल। यह समस्या कभी खत्म नहीं हुई। हार्डवेयर सस्ता हो गया, इसलिए जो हिस्सा कभी रिसर्च ग्रांट मांगता था, वह अब कुछ डॉलर प्रति माह में मिल जाता है।
1959 से 1961: time-sharing का आविष्कार क्यों हुआ
1950 के दशक में कई computers batch processing पर चलते थे, हालाँकि MIT का Whirlwind 1951 में ही real-time में interactively काम करता था। Batch processing में, आप अपने program को cards पर punch करते थे, deck को operator को सौंपते थे, और बाद में printout लेने के लिए वापस आते थे। एक गलत type किया गया character आपका पूरा दिन बर्बाद कर देता था। machine व्यस्त रहती थी, जो कि मुख्य उद्देश्य था, क्योंकि IBM 7090 जैसी machine की कीमत लाखों dollars थी और इसके लिए प्रतीक्षा करने वाले लोगों का समय किसी invoice पर नहीं दिखता था।
जनवरी 1959 में John McCarthy ने MIT में एक memo में इसके विपरीत तर्क दिया। machine को व्यक्ति के लिए प्रतीक्षा करनी चाहिए। Christopher Strachey ने उसी वर्ष एक UNESCO conference में time-sharing के एक रूप का वर्णन किया, हालाँकि उनका तात्पर्य एक साथ कई लोगों के type करने के बजाय एक programmer द्वारा debugging करने से था जबकि अन्य jobs चल रही हों। 1961 में MIT की शताब्दी समारोह में बोलते हुए, McCarthy ने और आगे बढ़कर कहा: computing को एक public utility के रूप में बेचा जा सकता है, जिसे बिजली की तरह meter किया जा सके।
उस समय आपत्ति यह थी कि time-sharing से machine बर्बाद होती है। 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 को अक्टूबर 1969 में MIT Information Processing Center के ग्राहकों के लिए खोला गया, और फिर यह इकतीस वर्षों तक मूल हार्डवेयर पर प्रोडक्शन में चला। मूल Multics हार्डवेयर चलाने वाली अंतिम साइट, जो हैलिफ़ैक्स, नोवा स्कोटिया में Canadian Department of National Defence में थी, उसे 30 अक्टूबर 2000 को बंद कर दिया गया। Multics आज सिम्युलेटेड हार्डवेयर पर चलता है, जिसमें Gold Hill भी शामिल है, जहाँ उपयोगकर्ता अकाउंट के लिए अनुरोध कर सकते हैं।
Multics को अक्सर एक विफलता के रूप में दर्ज किया जाता है क्योंकि यह देर से आया और धीमा चला। शब्दावली कुछ और ही कहती है। इसने हमें डायरेक्टरी के अंदर डायरेक्टरी वाली पदानुक्रमित फाइल सिस्टम (hierarchical file system), प्रत्येक फाइल पर एक्सेस कंट्रोल लिस्ट, सेगमेंटेड वर्चुअल मेमोरी जिसने प्रोग्राम को फाइल को मेमोरी की तरह एड्रेस करने की सुविधा दी, और प्रोटेक्शन रिंग्स दीं जो कोड को इस आधार पर रैंक करती थीं कि उस पर कितना भरोसा किया जा सकता है। रिंग्स आज भी आपके सामने मौजूद सिलिकॉन में हैं। Honeywell Multics हार्डवेयर ने इनमें से आठ प्रदान की थीं, जिन्हें 0 से 7 तक क्रमांकित किया गया था, जिसमें सबसे अधिक विशेषाधिकार प्राप्त कोड रिंग 0 में और सामान्य उपयोगकर्ता प्रोग्राम रिंग 4 में थे; आंतरिक रिंग्स सुरक्षित सबसिस्टम का भी समर्थन करती थीं। Intel के x86 ने इस शब्द को बरकरार रखा और कर्नेल के लिए रिंग 0 को रखा, लेकिन संख्या घटाकर चार कर दी, यही कारण है कि आपके VPS पर उपयोगकर्ता कोड रिंग 3 में चलता है। हार्डवेयर वर्चुअलाइजेशन ने बाद में हाइपरवाइजर के लिए रिंग 0 के नीचे एक मोड जोड़ा, जिसे लोग अनौपचारिक रूप से रिंग -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 ने उसी लक्ष्य पर दूसरे छोर से काम किया। कई users को सेवा देने वाले एक operating system के बजाय, Robert Creasy और Les Comeau ने एक control program बनाया जिसने प्रत्येक user को एक पूर्ण simulated computer दिया। CP-40 जनवरी 1967 में production में आया। प्रत्येक user को एक virtual System/360 मिला और उसने उसके अंदर एक छोटा single-user operating system, CMS, चलाया।
System/360-67 के लिए CP-67 का काम 1967 की शरद ऋतु में पूरा हुआ और यह जुलाई 1968 में Model 67 users के लिए उपलब्ध हो गया, और 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 होने के लिए एक पर्याप्त शर्त निर्धारित की। मुख्य नियम संक्षिप्त है। प्रत्येक sensitive instruction को privileged होना चाहिए, जो guest द्वारा kernel mode के बाहर execute किए जाने पर trap हो जाए, ताकि hypervisor नियंत्रण ले सके और उस guest के अपने निजी state version के साथ उत्तर दे सके। Sensitive instructions संसाधन आवंटन (resource allocation) को नियंत्रित करते हैं या मशीन के mode या memory mapping के आधार पर अलग तरह से व्यवहार करते हैं। सामान्य अंकगणितीय और memory operations सीधे hardware पर execute होते हैं। इसे trap and emulate कहा जाता है। IBM का hardware इस नियम का पालन करता था।
मिनीकंप्यूटर ने मॉडल को कैसे तोड़ा
DEC ने 1965 में PDP-8 को लगभग 18,000 डॉलर (1965 के मूल्य के अनुसार) में पेश किया। यह 20,000 डॉलर से कम कीमत वाला पहला मिनीकंप्यूटर था और इसकी 50,000 से अधिक इकाइयां बिकीं। इसके बाद माइक्रोप्रोसेसर ने कीमत को और कम कर दिया। जब एक विभाग अपना खुद का मशीन खरीद सकता था, और बाद में जब एक व्यक्ति ऐसा करने में सक्षम हुआ, तो एक केंद्रीय कंप्यूटर को साझा करना एक ऐसी समस्या लगने लगी जिसे हल करने की अब आवश्यकता नहीं थी। 1980 और 1990 के दशक के दौरान कंप्यूटिंग डेस्क तक और छोटे x86 servers के रैक में स्थानांतरित हो गई।
बर्बादी एक अलग रूप में वापस आ गई। प्रति सर्वर एक application के बारे में सोचना सरल है, लेकिन यह अधिकांश hardware को बेकार छोड़ देता है जबकि बिजली और रैक स्पेस का पूरा भुगतान किया जाता है। यह एक नए पैमाने पर फिर से वही CTSS समस्या है, जहाँ अब महंगा संसाधन प्रोसेसर के बजाय कमरा और बिजली है। इसका उत्तर वही पुराना उत्तर था। मशीन को साझा करें।
x86 को वर्चुअलाइज करना इतना कठिन क्यों था?
क्योंकि x86, Popek और Goldberg के नियम का पालन नहीं करता था। अगस्त 2000 में 9वें USENIX Security Symposium में, John Scott Robin और Cynthia Irvine ने Pentium instruction set का विश्लेषण किया और सत्रह ऐसी संवेदनशील instructions पाईं जो user mode में trap हुए बिना निष्पादित (execute) हो जाती थीं। popf इसका मानक उदाहरण है। यदि आप इसे user mode में चलाते हैं, तो प्रोसेसर चुपचाप उन bits को अनदेखा कर देता है जिन्हें प्रोग्राम सेट नहीं कर सकता, बजाय इसके कि वह trap करे। इस कारण trap-and-emulate पर आधारित hypervisor को कभी पता ही नहीं चलता कि guest ने ऐसा करने का प्रयास किया था।
हार्डवेयर में सुधार होने से पहले दो समाधान सामने आए। 1998 में Stanford के Disco शोध से स्थापित VMware ने guest kernel कोड का निरीक्षण किया और निष्पादन से पहले कठिन instructions को फिर से लिखा; इस तकनीक को binary translation कहा जाता है। University of Cambridge Computer Laboratory के Xen ने इसके बजाय guest को ही बदल दिया। अक्टूबर 2003 में SOSP में प्रस्तुत "Xen and the Art of Virtualization" शोध पत्र में paravirtualisation का वर्णन किया गया: इसमें एक संशोधित guest kernel उन instructions को चलाने के बजाय जिन्हें hypervisor इंटरसेप्ट नहीं कर सकता, जानबूझकर hypervisor को कॉल करता है।
फिर हार्डवेयर में सुधार किया गया, ठीक वैसे ही जैसे IBM ने 1960 के दशक में किया था। Intel ने 14 नवंबर 2005 को दो Pentium 4 मॉडल्स पर VT-x जारी किया और AMD ने मई 2006 में AMD-V जारी किया। दोनों ने guest kernel के नीचे एक नया प्रोसेसर मोड जोड़ा, जिससे guest अपना kernel पूरी गति से चला सकता है, जबकि hypervisor उन घटनाओं पर नियंत्रण रखता है जिन्हें वह ट्रैक करना चाहता है। इसने hypervisor को इतना छोटा बना दिया कि वह एक सामान्य ऑपरेटिंग सिस्टम के भीतर रह सके, और Qumranet में Avi Kivity के KVM ने बिल्कुल यही किया: इसने Linux kernel को ही hypervisor में बदल दिया। KVM को Linux 2.6.20 में मर्ज किया गया, जिसे फरवरी 2007 में रिलीज किया गया था।
VPS का नाम कैसे पड़ा
2000 के दशक की शुरुआत में दो धाराएं एक साथ मिलीं। एक थी x86 पर पूर्ण virtual machine, जो अपना kernel खुद boot करती थी। दूसरी थी operating-system-level virtualisation: एक साझा Linux kernel जिसे अलग-अलग environments में विभाजित किया गया था, जहाँ हर environment का अपना root user और अपनी process table होती थी। Linux-VServer और SWsoft के Virtuozzo ने यह मॉडल पेश किया, और 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 load कर सकते हैं और, जब host आवश्यक virtualisation features प्रदान करता है, तो आप अपने VPS के अंदर एक hypervisor चला सकते हैं। container-आधारित plan अपना kernel boot करने के बजाय host के kernel को साझा करता है। pricing page पर लिखी उस एक पंक्ति के पीछे साठ वर्षों का इतिहास है, और इसीलिए यह समझना फायदेमंद है कि एक VPS, एक VM और एक VPC में क्या अंतर है, इससे पहले कि आप किसी एक को चुनें।
Mainframe से आपके VPS तक क्या बदला, और क्या नहीं बदला
चार चीजें बदली हैं। मशीन आपकी इमारत में नहीं है। टर्मिनल अब फर्नीचर का एक टुकड़ा होने के बजाय एक प्रोग्राम है। आप जो यूनिट किराए पर लेते हैं, वह किसी और के ऑपरेटिंग सिस्टम पर केवल एक अकाउंट होने के बजाय अपना खुद का kernel वाला एक पूरा कंप्यूटर है। और कीमत इतनी कम हो गई है कि खरीदारी एक procurement प्रक्रिया के बजाय कार्ड से भुगतान बन गई है।
कार्यप्रणाली बिल्कुल नहीं बदली है।
- आपका ssh session एक time-sharing टर्मिनल है। आपको एक login और एक shell मिलता है, और एक scheduler तय करता है कि आपकी process अगली बार कब चलेगी।
- Isolation अभी भी hardware द्वारा लागू किया जाता है। MMU और प्रोसेसर के privilege levels वही काम करते हैं, ठीक वैसे ही जैसे 1967 में CP-40 को उनकी आवश्यकता थी।
- आपसे अभी भी मशीन के एक हिस्से के लिए elapsed time के आधार पर शुल्क लिया जाता है, ठीक वैसे ही जैसे service bureaus connect hours के लिए बिल भेजते थे।
- आप अभी भी अन्य tenants का प्रभाव महसूस करते हैं। जब एक host oversubscribed होता है, तो आपका guest एक physical CPU के लिए प्रतीक्षा करता है, और Linux उस प्रतीक्षा को noisy neighbour से CPU steal time के रूप में रिपोर्ट करता है।
वह अंतिम बिंदु पूरे इतिहास का ईमानदार सारांश है। एक मशीन साझा करना एक समझौता है। इसे 1961 में स्वीकार किया गया था क्योंकि कंप्यूटर की लागत लोगों से अधिक थी, और इसे 2026 में स्वीकार किया जाता है क्योंकि अपनी क्षमता के दस प्रतिशत पर चल रहा सर्वर पैसे की बर्बादी है। यदि आप उस समझौते के ऑपरेटर पक्ष में रहना पसंद करते हैं, तो अपने स्वयं के hardware पर Proxmox चलाना आपको hypervisor और ऑपरेटर की समस्याएं एक साथ देता है।
अनुपात को ध्यान में रखें। CTSS ने एक कमरे में भरी मशीन पर चार उपयोगकर्ताओं को सेवा दी थी। 2026 में कुछ डॉलर प्रति माह पर आपका VPS, Corbató की टीम द्वारा ration किए जा रहे कंप्यूटर से कहीं बेहतर कंप्यूटर है, और यह पूरी तरह आपके पास है। आप इसे किराए पर ले पा रहे हैं क्योंकि यह पैंसठ साल पुराना विचार है जो अंततः सस्ते hardware के साथ मिला है। यदि आप यह तय कर रहे हैं कि इस पर क्या डालना है, तो VPS वास्तव में आपको क्या देता है से शुरुआत करें और फिर लोग इस पर क्या चलाते हैं देखें।
FAQ
पहला time-sharing कंप्यूटर सिस्टम कौन सा था?
CTSS (Compatible Time-Sharing System), जिसे MIT Computation Center में Fernando Corbató के समूह द्वारा बनाया गया था, पहले सामान्य-उद्देश्य वाले time-sharing सिस्टम में से एक था। इसे पहली बार नवंबर 1961 में IBM 709 पर प्रदर्शित किया गया था और यह चार users को सेवा प्रदान करता था, जिनमें से प्रत्येक को अलग tape drive पर swap किया जाता था। CTSS ने मई 1963 में MIT users को सेवा देना शुरू किया। इसके बाद 1 मई 1964 को Dartmouth Time-Sharing System आया, जिसने दो terminals पर एक साथ BASIC programs को सफलतापूर्वक चलाया और दोनों को सही उत्तर दिए।
क्या virtual machines वास्तव में 1960 के दशक में खोजी गई थीं?
हाँ। IBM के Cambridge Scientific Center ने जनवरी 1967 में CP-40 को production में उतारा, जिससे प्रत्येक user को एक पूर्ण virtual System/360 मिला, जिसके अंदर CMS operating system चल रहा था। System/360-67 के लिए CP-67 को 1967 की शरद ऋतु में पूरा किया गया और यह जुलाई 1968 में Model 67 users के लिए उपलब्ध हुआ, और IBM ने 2 अगस्त 1972 को VM/370 की घोषणा की। ये वास्तविक hypervisors थे जो unmodified guest operating systems को चलाते थे, और VM/370 को व्यावसायिक रूप से बेचा गया था, x86 hardware के ऐसा करने में सक्षम होने से दशकों पहले।
x86 को virtualise करना कठिन क्यों था जबकि mainframes नहीं थे?
Popek और Goldberg की 1974 की पर्याप्त शर्त (sufficient condition) कहती है कि प्रत्येक sensitive instruction को privileged होना चाहिए, ताकि जब कोई guest इसे kernel mode के बाहर चलाए तो वह trap हो जाए; सामान्य अंकगणितीय और memory operations सीधे निष्पादित होते हैं। x86 ने उस नियम को तोड़ दिया। Robin और Irvine ने सत्रह ऐसे sensitive Pentium instructions की गणना की जो बिना trap हुए user mode में निष्पादित होते हैं, इसलिए एक क्लासिक 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 देता है।