Kasaysayan ng Computing: Mula Mainframe Hanggang VPS

Pinagmumulan ng iyong VPS

Ang kasaysayan ng computing mula sa mainframe hanggang sa cloud ay kasaysayan ng isang ideyang patuloy na bumababa ang halaga. Ang ideyang iyon ay time-sharing: maraming tao ang gumagamit ng isang mamahaling machine nang sabay-sabay, habang may pribadong view ang bawat isa sa machine na iyon. Naimbento ito noong bandang 1960 dahil mas mahal ang isang computer kaysa sa mga taong gumagamit nito. Binuo ang bawat bahagi ng VPS na nirerentahan mo ngayon para lutasin ang problemang iyon: ang isolation sa pagitan ng mga user, ang scheduler na namamahagi ng CPU time, ang hypervisor, at ang billing na nagbibilang ng mga oras. Hindi nawala ang problemang ito. Bumaba ang presyo ng hardware, kaya ang isang slice na dating nangangailangan ng research grant ay nagkakahalaga na lamang ngayon ng ilang dolyar bawat buwan.

1959 hanggang 1961: bakit naimbento ang time-sharing

Noong 1950s, batch processing ang paraan ng pagpapatakbo ng computer. Ipinapasok mo ang program sa mga punched card, ibinibigay ang deck sa operator, at bumabalik ka kalaunan para kunin ang printout. Kapag may isang character na mali ang pagkaka-type, isang araw ang nasasayang. Patuloy na abala ang machine, at iyon ang pangunahing layunin, dahil milyun-milyong dolyar ang halaga ng machine gaya ng IBM 7090 at hindi nakalagay sa anumang invoice ang oras ng mga taong naghihintay rito.

Noong Enero 1959, inilahad ni John McCarthy ang kabaligtarang pananaw sa isang memo sa MIT. Dapat maghintay ang machine para sa tao. Inilarawan ni Christopher Strachey ang isang anyo ng time-sharing sa isang UNESCO conference noong parehong taon, bagaman ang tinutukoy niya ay isang programmer na nagde-debug habang tumatakbo ang ibang job, hindi maraming taong sabay-sabay na nagta-type. Sa pagsasalita sa centennial ng MIT noong 1961, mas pinalawak pa ni McCarthy ang ideya: maaaring ibenta ang computing bilang public utility na sinusukat ang bayad tulad ng kuryente.

Ang pagtutol noon ay nasasayang ng time-sharing ang machine. May mga cycle na nagagamit sa paglipat-lipat sa pagitan ng mga user, at ang mga cycle ang mahalaga at magastos. Tama ang pagtutol na ito, ngunit kalaunan ay hindi na ito naging mahalaga, dahil bumaba ang presyo ng isang cycle sa loob ng 60 taon samantalang hindi bumaba ang presyo ng isang oras ng atensyon ng tao.

Mga kailangang imbentuhin ng CTSS

Binuo ng grupo ni Fernando Corbató sa MIT Computation Center ang Compatible Time-Sharing System (CTSS) upang lutasin ang pagtatalo. Una itong ipinakita noong November 1961 sa isang IBM 709, na nagseserbisyo sa apat na user at inililipat ang trabaho ng bawat user sa sarili nitong magnetic tape drive. Ang ibig sabihin ng “Compatible” ay maaari pa ring patakbuhin ng machine ang dating batch system sa ilalim nito, dahil walang bibili ng computer na isang bagong function lang ang kayang gawin.

Maliit na bilang ang apat na user. Ngunit mahaba ang listahan ng mga problemang kailangang lutasin upang maabot iyon, at iyon din ang listahang pinoproseso ng kernel mo ngayon. Kailangan ng CTSS ng scheduler upang hindi ma-freeze ng isang matagal na job ang lahat ng ibang terminal. Kailangan nito ng memory protection upang isang user lang ang maapektuhan kapag nag-crash ang isang program, sa halip na ang buong system. Kailangan nito ng storage na nananatili pagkatapos ng logout, kaya nagkaroon ang CTSS ng isa sa mga unang file system na makikilala ng modernong user. Kailangan din nito ng mga password upang hindi mabasa ng isang user ang mga file ng ibang user.

Palitan ang pangalan ng mga bahaging iyon at mayroon ka nang Linux box. Ang scheduler ay EEVDF, na pumalit sa CFS sa Linux 6.6. Ang memory protection ay ang MMU (memory management unit) na nagbibigay sa bawat process ng sarili nitong virtual address space. Ang storage na nananatili pagkatapos ng logout ay ang home directory mo. Ang password file ay tinatawag pa rin na /etc/passwd.

Multics at ang computer utility

Ang susunod na system ng MIT ay nilayong maging utility na inilarawan ni McCarthy. Nagsimula ang Project MAC noong 1963, pumirma para sa isang General Electric GE-645 noong August 1964, at inilathala ang mga unang papel tungkol sa Multics noong 1965. Nasa pangalan mismo ang konsepto: Multiplexed Information and Computing Service. Service ito sa diwa ng serbisyong binabayaran kada oras.

Mas matagal kaysa sa plano ang pagbuo sa Multics. Dumating sa MIT at Bell Labs ang mga prototype na GE-645 machine noong January 1967. Umalis ang Bell Labs sa proyekto noong April 1969. Binuksan ang Multics para sa mga customer ng MIT Information Processing Center noong 1 October 1969, at tumakbo ito sa production sa isang lugar sa loob ng tatlumpu't isang taon. Isinara ang huling aktibong Multics system sa Canadian Department of National Defence sa Halifax, Nova Scotia, noong 30 October 2000.

Madalas ituring na kabiguan ang Multics dahil nahuli itong dumating at mabagal itong tumakbo. Ngunit iba ang ipinapakita ng bokabularyo nito. Ipinakilala nito ang hierarchical file system na may mga directory sa loob ng ibang directory, access control list para sa bawat file, segmented virtual memory na nagpapahintulot sa program na i-address ang isang file na parang memory, at protection ring na nagraranggo sa code batay sa antas ng tiwalang ibinibigay rito. Nasa silicon pa rin sa harap mo ang mga ring. Ang ring 0 para sa kernel at ring 3 para sa user code ay bokabularyo ng Multics. Kalaunan, nagdagdag ang hardware virtualisation ng mode sa ilalim ng ring 0 para sa hypervisor, na impormal na tinatawag ng mga tao na ring -1.

Unix: time-sharing sa abot-kayang machine

Dahil iniwan ni Ken Thompson ang Multics, wala na siyang sistemang gusto niyang gamitin sa Bell Labs. Noong 1969, nagsimula siya ng mas maliit na sistema sa isang itinapong PDP-7. May petsang November 1971 ang unang Unix Programmer's Manual. Noon, nailipat na ang gawain sa PDP-11. Noong 1973, muling isinulat nina Thompson at Dennis Ritchie ang kernel sa C. Dahil dito, maaaring ilipat ang sistema sa bagong hardware nang hindi ito kailangang muling isulat nang mano-mano.

Iyan ang dahilan kung bakit nagta-type ka sa isang descendant ng Unix at hindi sa descendant ng Multics. Nangailangan ang Multics ng hardware na ginawa para sa Multics. Gumagana ang Unix sa anumang hardware na mura at available. Iyon ang naging katangiang nagpasya sa resulta.

Ang “The UNIX Time-Sharing System” nina Ritchie at Thompson ay inilathala sa Communications of the ACM noong July 1974. Inilalarawan ng paper ang VPS mo: mga process, isang hierarchical file system, mga file bilang plain byte streams, fork, mga user at group na may permission bits, at isang shell na ordinaryong program sa halip na bahagi ng kernel. Makalipas ang fifty-two years, pinalawig ang interface na iyon ngunit hindi ito pinalitan.

Talaga bang nagpapatakbo ng virtual machines ang mga mainframe noong 1972?

Oo, at ito ang bahagi ng kuwento na madalas nakakaligtaan ng mga tao. Habang binubuo ng MIT ang Multics, tinugunan ng IBM's Cambridge Scientific Center ang parehong layunin mula sa kabilang direksiyon. Sa halip na isang operating system na nagsisilbi sa maraming user, gumawa sina Robert Creasy at Les Comeau ng isang control program na nagbibigay sa bawat user ng kumpletong simulated computer. Pumasok sa production ang CP-40 noong January 1967. Binigyan ang bawat user ng virtual System/360 at nagpatakbo ito ng maliit na single-user operating system na CMS sa loob ng virtual machine.

Naging CP-67 ang CP-40 sa System/360-67 noong 1968, at inanunsyo ng IBM ang VM/370 noong 2 August 1972. Isa itong commercial hypervisor na ibinenta sa mga customer na nagbabayad, limampu't apat na taon na ang nakalipas. Nagmu-multiplex ang isang control program ng aktuwal na hardware, at tumatakbo ang mga guest operating system nang hindi binabago sa loob ng virtual machines na naniniwalang sila ang may-ari ng machine.

Dumating ang teorya makalipas ang dalawang taon, sa parehong July 1974 issue ng Communications of the ACM na naglathala rin ng Unix paper. Inilahad nina Gerald Popek at Robert Goldberg sa "Formal Requirements for Virtualizable Third Generation Architectures" kung ano ang kailangang gawin ng isang processor upang maging virtualizable. Maikli ang pangunahing tuntunin. Kailangang mag-trap ang bawat instruction na maaaring bumasa o magbago sa state ng machine kapag isinagawa ito ng guest sa labas ng kernel mode, upang makontrol ng hypervisor ang pagpapatupad at tumugon gamit ang pribadong bersiyon ng state para sa guest na iyon. Tinatawag itong trap and emulate. Sinunod ng hardware ng IBM ang tuntuning ito.

Paano binago ng minicomputer ang dating modelo

Ipinakilala ng DEC ang PDP-8 noong 22 March 1965 sa halagang humigit-kumulang $18,000 batay sa halaga ng dolyar noong 1965. Ito ang unang minicomputer na nagkakahalaga nang mas mababa sa $20,000, at umabot sa mahigit 50,000 unit ang naibenta nito. Pagkatapos, lalo pang nagpababa ng presyo ang microprocessor. Nang makabili na ang isang department ng sarili nitong machine, at kalaunan ay makabili na rin ang isang indibidwal, nagmukhang nalutas na ang problema sa pagbabahagi ng isang central computer at hindi na ito kailangang lutasin pa. Sa buong 1980s at 1990s, lumipat ang computing sa mga desk at sa racks ng maliliit na x86 server.

Bumalik ang aksaya sa ibang anyo. Madaling unawain at i-manage ang isang application bawat server, pero karamihan sa hardware ay nananatiling idle habang buo pa ring binabayaran ang kuryente at rack space. Muli itong problema ng CTSS, ngunit nasa mas malaking scale. Ang mahal na resource ngayon ay ang silid at kuryente, hindi ang processor. Ang solusyon ay ang dati ring solusyon. Ibahagi ang machine.

Bakit napakahirap i-virtualize ang x86?

Dahil lumabag ang x86 sa tuntunin nina Popek at Goldberg. Sa 9th USENIX Security Symposium noong August 2000, sinuri nina John Scott Robin at Cynthia Irvine ang Pentium instruction set at nakakita sila ng labimpitong instruction na nagbabasa o nagbabago ng privileged state nang hindi nagti-trigger ng fault kapag user-mode code ang nagpapatakbo sa mga ito. Ang popf ang karaniwang halimbawa. Kapag pinatakbo ito sa user mode, tahimik na binabalewala ng processor ang mga bit na hindi pinapayagang i-set ng program, sa halip na mag-trap. Dahil dito, hindi nalalaman ng hypervisor na gumagamit ng trap-and-emulate approach na sinubukan ng guest na patakbuhin ang instruction.

Dalawang solusyon ang lumitaw bago naayos ang hardware. Sinuri ng VMware, na itinatag noong 1998 mula sa Disco research ng Stanford, ang guest kernel code at pinalitan ang mahihirap na instruction bago pa maisagawa ang mga ito. Tinatawag itong binary translation. Sa kabilang banda, binago ng Xen mula sa University of Cambridge Computer Laboratory ang guest. Inilarawan ng paper na "Xen and the Art of Virtualization", na ipinresenta sa SOSP noong October 2003, ang paravirtualisation: sadyang tumatawag ang binagong guest kernel sa hypervisor sa halip na magpatakbo ng mga instruction na hindi kayang i-intercept ng hypervisor.

Pagkatapos, inayos ang hardware sa paraang katulad ng ginawa ng IBM noong 1960s. Inilabas ng Intel ang VT-x sa dalawang Pentium 4 model noong 14 November 2005, at inilabas naman ng AMD ang AMD-V noong May 2006. Pareho silang nagdagdag ng processor mode na nasa ibaba ng mode ng guest kernel. Dahil dito, tumatakbo ang guest gamit ang sarili nitong kernel sa full speed, habang nananatiling kontrolado ng hypervisor ang mga event na kailangan nitong pangasiwaan. Dahil dito, naging sapat na maliit ang hypervisor para tumakbo sa loob ng ordinaryong operating system. Ganoon mismo ang ginawa ng KVM ni Avi Kivity sa Qumranet: ginawa nitong hypervisor ang Linux kernel mismo. Isinama ang KVM sa Linux 2.6.20, na inilabas noong February 2007, at ito ang ginagamit ngayon ng malaking bahagi ng mga VPS host.

Paano nakuha ng VPS ang pangalan nito

Dalawang linya ang nagtagpo noong unang bahagi ng 2000s. Ang isa ay ang ganap na virtual machine sa x86, kung saan nagbo-boot ang guest gamit ang sarili nitong kernel. Ang isa naman ay operating-system-level virtualisation: isang Linux kernel na pinaghahatian at hinahati sa magkakahiwalay na environment, na bawat isa ay may sariling root user at sariling process table. Parehong lumitaw noong 2001 ang Linux-VServer at Virtuozzo ng SWsoft, at inilabas ng SWsoft ang bahagi ng Virtuozzo bilang open-source na OpenVZ noong 2005. Mula sa panig na ito ng pamilya nagmula ang pariralang “virtual private server,” na binuo bilang analohiya sa virtual private network.

Ginawang API call ng Amazon ang pagrenta. Inilunsad ang S3 noong 14 March 2006, at binuksan ang EC2 bilang limitadong public beta noong 25 August 2006 gamit ang iisang instance type na tumatakbo sa Xen. Hindi na pagbili ng compute bilang kontrata sa service bureau ang proseso. Naging request na ito na nagbabalik ng resulta sa loob ng isang minuto.

Pareho pa ring umiiral ang dalawang linya, at ang pagkakahating ito ang patuloy na nagtatakda kung ano ang magagawa mo sa server na inuupahan mo. Nagbo-boot ang KVM VPS gamit ang sarili nitong kernel, kaya maaari kang mag-load ng kernel modules at magpatakbo pa ng hypervisor sa loob ng iyong VPS. Ibinabahagi naman ng container-based plan ang kernel ng host at hindi ito magagawa. Animnapung taon ng kasaysayan ang nasa likod ng isang linyang iyon sa pricing page. Kaya mahalagang maunawaan muna kung paano nagkakaiba ang VPS, VM, at VPC bago ka pumili.

Ano ang nagbago mula sa mainframe patungo sa iyong VPS, at ano ang hindi

Apat na bagay ang nagbago. Wala na ang machine sa iyong gusali. Program na ang terminal sa halip na isang pisikal na kagamitan. Ang nirentahan mong unit ay isang buong computer na may sarili nitong kernel, hindi account sa operating system ng ibang tao. Bumaba rin nang sapat ang presyo kaya card payment na ang pagbili sa halip na procurement process.

Hindi nagbago ang mekanismo.

• Ang iyong ssh session ay isang time-sharing terminal. May login at shell ka, at isang scheduler ang nagpapasya kung kailan muling tatakbo ang iyong process.
• Hardware pa rin ang nagpapatupad ng isolation. Ang MMU at privilege levels ng processor ang gumagawa nito, gaya ng kinakailangan ng CP-40 noong 1967.
• Sinisingil ka pa rin para sa bahagi ng isang machine batay sa lumipas na oras, gaya ng pagsingil ng mga service bureau para sa connect hours.
• Nararamdaman mo pa rin ang ibang tenant. Kapag oversubscribed ang isang host, naghihintay ang guest mo ng physical CPU, at iniuulat ng Linux ang paghihintay na iyon bilang CPU steal time mula sa maingay na katabing tenant.

Iyan ang pinakatapat na buod ng buong kasaysayan. May kapalit ang pagbabahagi ng isang machine. Tinanggap ito noong 1961 dahil mas mahal ang computer kaysa sa mga tao, at tinatanggap ito noong 2026 dahil nasasayang ang perang ginugol sa server na tumatakbo sa sampung porsyento ng capacity nito. Kung mas gusto mong ikaw ang nasa panig ng operator sa ganitong trade-off, ibinibigay sa iyo ng pagpapatakbo ng Proxmox sa hardware na pagmamay-ari mo ang hypervisor at ang mga problema ng operator.

Tandaan ang ratio. Nagsilbi ang CTSS sa apat na user gamit ang isang machine na nagkakahalaga ng milyon-milyong 1961 dollars at sumasakop sa isang buong silid. Ang iyong VPS, sa halagang ilang dollars bawat buwan noong 2026, ay mas mahusay na computer kaysa sa pinaglalaanan ng oras ng team ni Corbató, at ikaw lamang ang gumagamit nito. Nagrenta ka nito dahil sa isang ideyang animnapu't limang taong gulang na sa wakas ay nakatugma sa murang hardware. Kung pinag-iisipan mo kung ano ang ilalagay dito, magsimula sa kung ano talaga ang ibinibigay sa iyo ng VPS at pagkatapos ay tingnan ang mga karaniwang pinapatakbo ng mga tao rito.

FAQ

Ano ang unang computer system na may time-sharing?

Ang CTSS, o Compatible Time-Sharing System, na binuo ng grupo ni Fernando Corbató sa MIT Computation Center. Una itong ipinakita noong November 1961 sa isang IBM 709 at nagsilbi sa apat na user. Bawat user ay ini-swap papunta sa magkakahiwalay na tape drive. Ang unang time-sharing service para sa isang buong komunidad ay ang Dartmouth Time-Sharing System. Noong 1 May 1964, sabay na nagpatakbo ng BASIC programs sa dalawang terminal sina John Kemeny at isang student programmer, at parehong nakatanggap ng tamang sagot.

Talaga bang naimbento ang virtual machines noong 1960s?

Oo. Inilagay ng IBM's Cambridge Scientific Center sa production ang CP-40 noong January 1967. Binigyan nito ang bawat user ng kumpletong virtual System/360 na pinapatakbo ang CMS operating system sa loob nito. Sinundan ito ng CP-67 noong 1968 sa System/360-67, at inanunsyo ng IBM ang VM/370 noong 2 August 1972. Mga tunay na hypervisor ang mga iyon na nagpapatakbo ng mga guest operating system na walang pagbabago. Komersiyal na ibinenta ang mga ito ilang dekada bago kayang gawin ng x86 hardware ang parehong bagay.

Bakit mahirap i-virtualize ang x86 samantalang hindi ito naging mahirap sa mainframes?

Ayon sa tuntunin nina Popek at Goldberg noong 1974, dapat mag-trap ang bawat instruction na maaaring bumasa o magbago ng machine state kapag pinatakbo ito ng guest sa labas ng kernel mode. Nilabag ng x86 ang tuntuning ito. Binilang nina Robin at Irvine ang labing-pitong Pentium instructions na tahimik na nagfa-fail sa user mode sa halip na mag-trap. Dahil dito, hindi nakikita ng classic trap-and-emulate hypervisor ang mga ito, at popf ang karaniwang halimbawa. Gumamit ang VMware ng binary translation bilang workaround, samantalang gumamit ang Xen ng paravirtualisation. Nagbago ito nang idagdag ng Intel VT-x noong November 2005 at AMD-V noong May 2006 ang hardware mode para sa hypervisor.

Pareho ba ang pag-renta ng VPS at pagkakaroon ng time-sharing account?

Pareho ang billing model at ang isolation problem. Magkaiba ang unit. Ang time-sharing user ay nagkaroon ng account sa isang operating system na kahati ng lahat ng iba pang user. Dahil dito, ang administrator ay isang tao sa computer centre. Ang KVM VPS ay nagbibigay sa iyo ng virtual machine na may sarili mong kernel at sarili mong root account. Kaya ikaw ang administrator. Ang container-based VPS ay nasa pagitan ng dalawang ito dahil kahati nito ang host kernel, ngunit binibigyan ka pa rin nito ng root sa sarili mong environment.