SSD Nodes Learn Hosting plans →
מדריכים Matt Connorמאת Matt Connor

ההיסטוריה של ה-VPS: ממיינפריים ועד לענן

גלו כיצד ה-VPS שאתם שוכרים היום הוא צאצא ישיר של מערכות ה-time-sharing משנות ה-60. נסקור את האבולוציה מ-CTSS ו-Unix ועד לטכנולוגיות ה-KVM וה-hypervisor המודרניות.

מקור ה-VPS שלכם

ההיסטוריה של המחשוב, מהמיינפריים ועד לענן, היא סיפור על רעיון שהופך לזול יותר. הרעיון הזה הוא שיתוף זמן (time-sharing): מתן אפשרות לאנשים רבים להשתמש במכונה יקרה אחת בו-זמנית, תוך מתן תצוגה פרטית לכל אחד מהם. הרעיון הומצא בסביבות שנת 1960, מכיוון שמחשב עלה יותר מהאנשים שהשתמשו בו. כל חלק ב-VPS שאתם שוכרים כיום נבנה עבור הבעיה הזו: הבידוד בין משתמשים, מתזמן המשימות שמקצה זמן מעבד, ה-hypervisor, והחשבונית שסופרת שעות. הבעיה מעולם לא נעלמה. החומרה הפכה לזולה, כך שפלח משאבים שפעם דרש מענק מחקר עולה כיום כמה דולרים בודדים בחודש.

1959 עד 1961: מדוע הומצא ה-time-sharing

מחשבים רבים בשנות ה-50 פעלו בשיטת batch, אם כי ה-Whirlwind של MIT פעל באופן אינטראקטיבי בזמן אמת כבר ב-1951. בעיבוד batch, היית מנקב את התוכנית שלך על כרטיסים, מוסר את החבילה למפעיל, וחוזר מאוחר יותר לקבל פלט מודפס. תו אחד שהוקלד בשגגה עלה לך ביום עבודה. המכונה נשארה עסוקה, וזו הייתה כל המטרה, כיוון שמכונה כמו ה-IBM 7090 עלתה מיליוני דולרים, והזמן של האנשים שהמתינו לה לא הופיע באף חשבונית.

בינואר 1959 הציג John McCarthy את הטיעון ההפוך בתזכיר ב-MIT. המכונה צריכה להמתין לאדם. Christopher Strachey תיאר צורה של time-sharing בכנס של UNESCO באותה שנה, אם כי הוא התכוון למתכנת אחד שמבצע ניפוי שגיאות בזמן שעבודות אחרות רצות, ולא לאנשים רבים שמקלידים בו-זמנית. בנאום שנשא בטקס המאה של MIT ב-1961, הרחיק McCarthy לכת: ניתן למכור מחשוב כשירות ציבורי, שיימדד כמו חשמל.

ההתנגדות באותה עת הייתה ש-time-sharing מבזבז את המכונה. מעבר בין משתמשים צורך מחזורי מעבד, ומחזורי מעבד היו המשאב היקר. ההתנגדות הייתה נכונה, אך היא חדלה מלהיות רלוונטית, כיוון שמחיר מחזור מעבד ירד במשך שישים שנה, בעוד שמחיר שעת תשומת לב אנושית לא ירד.

מה היה על CTSS להמציא

הקבוצה של Fernando Corbató במרכז המחשוב של MIT בנתה את ה-Compatible Time-Sharing System (CTSS) כדי ליישב את הוויכוח. המערכת הוצגה לראשונה בנובמבר 1961 על גבי IBM 709, כשהיא משרתת ארבעה משתמשים ומחליפה את עבודתו של כל משתמש לכונן סרט מגנטי ייעודי. "Compatible" (תואמת) פירושו שהמכונה עדיין יכלה להריץ את מערכת ה-batch הישנה ברקע, שכן איש אינו קונה מחשב שמסוגל לבצע רק את הדבר החדש.

ארבעה משתמשים הם מספר קטן. רשימת הבעיות שהיה צריך לפתור כדי להגיע לכך אינה קטנה, וזו אותה רשימה שה-kernel שלכם מטפל בה ברגע זה. CTSS נזקקה ל-scheduler, כדי שעבודה אחת ארוכה לא תקפיא כל טרמינל אחר. היא נזקקה להגנת זיכרון, כדי שתוכנית שקורסת תפיל משתמש אחד בלבד ולא את המערכת כולה. היא נזקקה לאחסון ששורד התנתקות (logout), וזו הסיבה של-CTSS הייתה אחת ממערכות הקבצים הראשונות שמשתמש מודרני יזהה. והיא נזקקה לסיסמאות, כדי שמשתמש אחד לא יוכל לקרוא קבצים של משתמש אחר.

שנו את השמות של החלקים הללו וקיבלתם מכונת Linux. ה-scheduler הוא EEVDF, שהחליף את CFS ב-Linux 6.6. הגנת זיכרון היא ה-MMU (יחידת ניהול זיכרון) המעניקה לכל תהליך מרחב כתובות וירטואלי משלו. אחסון ששורד התנתקות הוא ספריית הבית שלכם. קובץ הסיסמאות עדיין נקרא /etc/passwd.

Multics והמחשב כשירות

המערכת הבאה של MIT נועדה להיות השירות (utility) שתיאר McCarthy. פרויקט MAC החל ב-1963, נחתם עבור מחשב General Electric GE-645 באוגוסט 1964, והמאמרים הראשונים על Multics פורסמו ב-1965. השם מבהיר את הטיעון: Multiplexed Information and Computing Service. שירות, במובן של משהו שרוכשים לפי שעה.

פיתוח Multics ארך זמן רב בהרבה מהמתוכנן. מכונות ה-GE-645 האב-טיפוס הגיעו ל-MIT ול-Bell Labs בינואר 1967. Bell Labs עזבו את הפרויקט באפריל 1969. Multics נפתח ללקוחות מרכז עיבוד הנתונים של MIT באוקטובר 1969, ופעל בסביבת ייצור על החומרה המקורית במשך שלושים ואחת שנים. האתר האחרון שהפעיל חומרה מקורית של Multics, במשרד ההגנה הלאומי הקנדי בהליפקס, נובה סקוטיה, נסגר ב-30 באוקטובר 2000. כיום Multics פועל על חומרה מדומיינת, כולל ב-Gold Hill, שם משתמשים יכולים לבקש חשבונות.

Multics מסווג לעיתים קרובות ככישלון כיוון שהגיע באיחור ופעל לאט. אוצר המילים הטכני מעיד אחרת. הוא העניק לנו את מערכת הקבצים ההיררכית של ספריות בתוך ספריות, רשימת בקרת גישה (ACL) על כל קובץ, זיכרון וירטואלי מפולח שאפשר לתוכנית להתייחס לקובץ כאילו היה זיכרון, וטבעות הגנה (protection rings) שדירגו קוד לפי רמת המהימנות שלו. הטבעות עדיין נמצאות בסיליקון שלפניכם. חומרת Honeywell Multics סיפקה שמונה טבעות, ממוספרות מ-0 עד 7, כאשר הקוד בעל ההרשאות הגבוהות ביותר נמצא בטבעת 0 ותוכניות משתמש רגילות בטבעת 4; הטבעות הפנימיות תמכו גם בתתי-מערכות מוגנות. ארכיטקטורת x86 של Intel שמרה על המונח ועל טבעת 0 עבור ה-kernel, אך צמצמה את מספר הטבעות לארבע, וזו הסיבה שקוד משתמש ב-VPS שלכם רץ בטבעת 3. וירטואליזציה של חומרה הוסיפה מאוחר יותר מצב מתחת לטבעת 0 עבור ה-hypervisor, מצב שאנשים מכנים באופן לא רשמי טבעת 1-.

Unix: שיתוף זמן על מכונה שניתן להרשות לעצמך

עזיבת פרויקט Multics הותירה את Ken Thompson ממעבדות Bell ללא מערכת שבה רצה להשתמש. בשנת 1969 הוא החל לפתח מערכת קטנה בהרבה על מחשב PDP-7 שהוצא משימוש. המדריך הראשון למתכנתי Unix נושא את התאריך נובמבר 1971, נקודת זמן שבה העבודה כבר עברה למחשב PDP-11. בשנת 1973 שכתבו Thompson ו-Dennis Ritchie את ה-kernel בשפת C, כדי שהמערכת תוכל לעבור לחומרה חדשה מבלי להיכתב מחדש באופן ידני.

זו הסיבה שאתם מקלידים לתוך צאצא של Unix ולא לתוך צאצא של Multics. מערכת Multics דרשה חומרה שנבנתה עבורה. Unix רצה על כל מה שהיה זול וזמין, וזה התברר כמאפיין המכריע.

המאמר "The UNIX Time-Sharing System" מאת Ritchie ו-Thompson הופיע ב-Communications of the ACM ביולי 1974. המאמר מתאר את ה-VPS שלכם: תהליכים, מערכת קבצים היררכית אחת, קבצים כזרמי בתים פשוטים, fork, משתמשים וקבוצות עם סיביות הרשאה, ו-shell שהוא תוכנית רגילה ולא חלק מה-kernel. חמישים ושתיים שנים לאחר מכן, הממשק הזה הורחב, אך מעולם לא הוחלף.

האם מחשבי Mainframe באמת הריצו מכונות וירטואליות בשנת 1972?

כן, וזהו החלק בסיפור שרוב האנשים מפספסים. בזמן ש-MIT בנתה את Multics, המרכז המדעי של IBM בקיימברידג' תקף את אותה מטרה מהכיוון ההפוך. במקום מערכת הפעלה אחת המשרתת משתמשים רבים, רוברט קריסי (Robert Creasy) ולס קומו (Les Comeau) בנו תוכנית בקרה שהעניקה לכל משתמש מחשב מדומה מלא. CP-40 נכנס לייצור בינואר 1967. כל משתמש קיבל System/360 וירטואלי והריץ בתוכו מערכת הפעלה קטנה למשתמש יחיד בשם CMS.

הגרסה CP-67 עבור ה-System/360-67 הושלמה בסתיו 1967 והפכה זמינה למשתמשי Model 67 ביולי 1968, ו-IBM הכריזה על VM/370 ב-2 באוגוסט 1972. מדובר ב-hypervisor מסחרי, שנמכר ללקוחות משלמים, לפני חמישים וארבע שנים. תוכנית בקרה ביצעה מולטיפלקסינג לחומרה האמיתית, ומערכות הפעלה אורחות רצו ללא שינוי בתוך מכונות וירטואליות ש"האמינו" שהן הבעלים של המכונה.

התיאוריה הגיעה שנתיים מאוחר יותר, באותו גיליון של יולי 1974 של Communications of the ACM שכלל את המאמר על Unix. המאמר "Formal Requirements for Virtualizable Third Generation Architectures" מאת ג'רלד פופק (Gerald Popek) ורוברט גולדברג (Robert Goldberg) קבע תנאי מספיק לכך שמעבד יהיה ניתן לווירטואליזציה. הכלל המרכזי קצר. כל הוראה רגישה חייבת להיות מוגדרת כ-privileged, כך שתיווצר חריגה (trap) כאשר אורח מריץ אותה מחוץ למצב kernel, מה שמאפשר ל-hypervisor להשתלט ולהשיב עם גרסת המצב הפרטית של אותו אורח. הוראות רגישות שולטות בהקצאת משאבים או מתנהגות אחרת בהתאם למצב המכונה או למיפוי הזיכרון. פעולות חשבון וזיכרון רגילות מתבצעות ישירות על החומרה. תהליך זה נקרא trap and emulate. החומרה של IBM צייתה לכלל הזה.

מדוע המיני-מחשב שבר את המודל

חברת DEC הציגה את ה-PDP-8 בשנת 1965 במחיר של כ-18,000 דולר (בערכי 1965). זה היה המיני-מחשב הראשון שמחירו היה נמוך מ-20,000 דולר, והוא נמכר ביותר מ-50,000 יחידות. המיקרו-מעבד הוריד את המחיר פעם נוספת. ברגע שמחלקה יכלה לרכוש מכונה משלה, ומאוחר יותר ברגע שאדם פרטי יכול היה לעשות זאת, שיתוף של מחשב מרכזי אחד נראה כבעיה פתורה שאין צורך לעסוק בה יותר. במהלך שנות ה-80 וה-90, המחשוב עבר אל שולחן העבודה ואל ארונות שרתים קטנים מבוססי x86.

הבזבוז חזר בצורה אחרת. קל להבין מודל של יישום אחד לכל שרת, אך הוא מותיר את רוב החומרה במצב סרק, בעוד שעלויות החשמל והמקום בארון משולמות במלואן. זוהי שוב בעיית ה-CTSS בקנה מידה חדש, כאשר המשאב היקר הוא כעת החדר והחשמל ולא המעבד. התשובה הייתה התשובה הישנה: לשתף את המכונה.

מדוע היה קשה כל כך לבצע וירטואליזציה ל-x86?

מכיוון ש-x86 הפרה את הכלל של Popek ו-Goldberg. בסימפוזיון האבטחה ה-9 של USENIX באוגוסט 2000, ג'ון סקוט רובין וסינתיה אירווין ניתחו את סט הפקודות של Pentium ומצאו שבע-עשרה פקודות רגישות שמתבצעות ללא יצירת trap במצב משתמש (user mode). הפקודה popf היא הדוגמה הסטנדרטית לכך. הרצתה במצב משתמש גורמת למעבד להתעלם בשקט מהביטים שהתוכנית אינה מורשית לשנות, במקום ליצור trap. כתוצאה מכך, hypervisor המבוסס על מנגנון trap and emulate לעולם אינו מודע לכך שהאורח (guest) ניסה לבצע פעולה זו.

שתי תשובות הופיעו לפני שהחומרה תוקנה. חברת VMware, שנוסדה ב-1998 מתוך מחקר ה-Disco באוניברסיטת סטנפורד, סרקה את קוד ה-kernel של האורח ושכתבה את הפקודות הבעייתיות לפני ביצוען – טכניקה הנקראת binary translation. לעומתה, Xen, ממעבדת המחשבים של אוניברסיטת קיימברידג', בחרה לשנות את האורח עצמו. המאמר "Xen and the Art of Virtualization", שהוצג ב-SOSP באוקטובר 2003, תיאר paravirtualisation: גרעין אורח שעבר התאמה קורא ל-hypervisor באופן יזום, במקום להריץ פקודות שה-hypervisor אינו יכול ליירט.

לאחר מכן החומרה תוקנה, בדומה לדרך שבה IBM תיקנה זאת בשנות ה-60. אינטל הפיצה את VT-x בשני דגמי Pentium 4 ב-14 בנובמבר 2005, ו-AMD הפיצה את AMD-V במאי 2006. שניהם הוסיפו מצב מעבד מתחת ל-kernel של האורח, כך שהאורח מריץ את ה-kernel שלו במהירות מלאה בעוד ה-hypervisor שומר על שליטה באירועים שהוא מגדיר. הדבר הפך את ה-hypervisor לקטן מספיק כדי לחיות בתוך מערכת הפעלה רגילה, וזה בדיוק מה ש-KVM של אבי קיביתי ב-Qumranet עשה: הוא הפך את ה-Linux kernel עצמו ל-hypervisor. ה-KVM מוזג לתוך Linux 2.6.20, ששוחרר בפברואר 2007.

כיצד קיבל ה-VPS את שמו

שני קווים התכנסו בתחילת שנות ה-2000. האחד היה מכונה וירטואלית מלאה על ארכיטקטורת x86, אורח המאתחל קרנל משלו. השני היה וירטואליזציה ברמת מערכת ההפעלה: קרנל Linux משותף יחיד המחולק לסביבות נפרדות, שלכל אחת מהן משתמש root משלה וטבלת תהליכים משלה. Linux-VServer ו-Virtuozzo של חברת SWsoft הציעו מודל זה, ו-SWsoft שחררה חלק מ-Virtuozzo כפרויקט הקוד הפתוח OpenVZ בשנת 2005. המונח "virtual private server" מגיע מצד זה של המשפחה, ונוצר בהשאלה מ-virtual private network.

חברת Amazon הפכה את ההשכרה לקריאת API. שירות S3 הושק ב-14 במרץ 2006, ו-EC2 נפתח כגרסת בטא ציבורית מוגבלת ב-25 באוגוסט 2006 עם סוג מופע (instance) יחיד, שרץ על גבי Xen. רכישת כוח מחשוב חדלה להיות חוזה מול לשכת שירות והפכה לבקשה המוחזרת בתוך דקה.

שני הקווים שורדים, והפיצול עדיין קובע מה ניתן לעשות עם השרת ששכרת. VPS מבוסס KVM מאתחל קרנל משלו, כך שניתן לטעון מודולי קרנל, וכאשר המארח חושף את תכונות הווירטואליזציה הנדרשות, להריץ hypervisor בתוך ה-VPS שלך. תוכנית מבוססת מכולות (container) משתפת את הקרנל של המארח במקום לאתחל קרנל משלה. שישים שנות היסטוריה עומדות מאחורי שורה אחת בדף תמחור, וזו הסיבה שכדאי להבין מה ההבדל בין VPS, VM ו-VPC לפני שבוחרים אחד.

מה השתנה מהמיינפריים ל־VPS שלך, ומה לא השתנה

ארבעה דברים השתנו. המכונה אינה נמצאת בבניין שלך. הטרמינל הוא תוכנה ולא רהיט. היחידה שאתה שוכר היא מחשב שלם עם kernel משלו, ולא חשבון על מערכת ההפעלה של מישהו אחר. והמחיר ירד מספיק כדי שהרכישה תתבצע בתשלום בכרטיס אשראי ולא בתהליך רכש מורכב.

המנגנון לא השתנה כלל.

  • ה־ssh session שלך הוא טרמינל של time-sharing. אתה מקבל login ו־shell, ומתזמן (scheduler) מחליט מתי התהליך שלך ירוץ.
  • בידוד עדיין נאכף על ידי חומרה. ה־MMU ורמות ההרשאה של המעבד מבצעים את העבודה, בדיוק כפי ש-CP-40 נזקק להם ב-1967.
  • אתה עדיין מחויב על חלק ממכונה לפי זמן, בדומה לאופן שבו לשכות שירות חייבו על שעות חיבור.
  • אתה עדיין מרגיש את הדיירים האחרים. כאשר השרת המארח עמוס מדי, ה־guest שלך ממתין ל־CPU פיזי, ו־Linux מדווחת על המתנה זו כ־CPU steal time משכן רועש.

הנקודה האחרונה היא הסיכום הכנה של ההיסטוריה כולה. שיתוף מכונה הוא פשרה. זה היה מקובל ב-1961 כי המחשב עלה יותר מהאנשים, וזה מקובל ב-2026 כי שרת שרץ בעשרה אחוזים מהקיבולת שלו הוא כסף שנשרף. אם אתה מעדיף לעמוד בצד של המפעיל בעסקה הזו, הרצת Proxmox על חומרה שבבעלותך מעניקה לך את ה־hypervisor ואת הבעיות של המפעיל גם יחד.

זכור את היחס. CTSS שירת ארבעה משתמשים על מכונה שמילאה חדר שלם. ה־VPS שלך, בעלות של דולרים בודדים לחודש בשנת 2026, הוא מחשב טוב בהרבה מזה שהצוות של Corbató הקציב, והוא כולו שלך. הסיבה שאתה יכול לשכור אותו בכלל היא רעיון בן שישים וחמש שנים שפגש סוף סוף חומרה זולה. אם אתה מנסה להחליט מה להריץ עליו, התחל ב־מה VPS באמת נותן לך ולאחר מכן מה אנשים מריצים על VPS.

FAQ

מה הייתה מערכת המחשב הראשונה שפעלה בשיטת time-sharing?

CTSS, ה-Compatible Time-Sharing System, שנבנתה על ידי הקבוצה של Fernando Corbató במרכז החישובים של MIT, הייתה אחת ממערכות ה-time-sharing הכלליות הראשונות. היא הוצגה לראשונה בנובמבר 1961 על גבי IBM 709 ושירתה ארבעה משתמשים, כאשר כל אחד מהם הועבר לכונן סרטים מגנטיים נפרד. CTSS החלה לשרת את משתמשי MIT במאי 1963. ה-Dartmouth Time-Sharing System הגיעה אחריה ב-1 במאי 1964, והריצה בהצלחה תוכניות BASIC בו-זמנית על שני מסופים תוך החזרת תשובות נכונות לשניהם.

האם מכונות וירטואליות באמת הומצאו בשנות ה-60?

כן. ה-Cambridge Scientific Center של IBM הכניס את CP-40 לייצור בינואר 1967, והעניק לכל משתמש System/360 וירטואלי מלא עם מערכת ההפעלה CMS שרצה בתוכו. ה-CP-67 עבור ה-System/360-67 הושלמה בסתיו 1967 והפכה לזמינה למשתמשי Model 67 ביולי 1968, ו-IBM הכריזה על VM/370 ב-2 באוגוסט 1972. אלו הם hypervisors אמיתיים המריצים מערכות הפעלה אורחות ללא שינוי, כאשר VM/370 נמכרה מסחרית עשורים לפני שחומרת x86 יכלה לבצע את אותה פעולה.

מדוע היה קשה לבצע וירטואליזציה ל-x86 בעוד שלמחשבי מיינפריים לא?

התנאי המספיק של Popek ו-Goldberg משנת 1974 קובע שכל פקודה רגישה חייבת להיות מוגדרת כ-privileged, כך שתיווצר חריגה (trap) כאשר מערכת אורחת מריצה אותה מחוץ למצב kernel; פעולות אריתמטיות וזיכרון רגילות מתבצעות ישירות. ארכיטקטורת x86 הפרה את הכלל הזה. Robin ו-Irvine מנו שבע-עשרה פקודות Pentium רגישות שמתבצעות במצב משתמש ללא יצירת trap, ולכן hypervisor קלאסי מסוג trap-and-emulate לעולם לא רואה אותן, ו-popf היא הדוגמה הנפוצה לכך. VMware עקפה זאת באמצעות binary translation ו-Xen באמצעות paravirtualisation, עד ש-Intel VT-x בנובמבר 2005 ו-AMD-V במאי 2006 הוסיפו מצב חומרה ייעודי עבור ה-hypervisor.

האם השכרת VPS זהה להחזקת חשבון time-sharing?

מודל החיוב ובעיית הבידוד זהים. היחידה עצמה שונה. משתמש time-sharing קיבל חשבון במערכת הפעלה ששותפה עם כולם, כך שהמנהל היה מישהו ממרכז המחשוב. VPS מבוסס KVM מעניק לך מכונה וירטואלית עם kernel משלך וחשבון root משלך, כך שהמנהל הוא אתה. VPS מבוסס מכולות (container) נמצא בתווך, כיוון שהוא משתף את ה-kernel של המארח אך עדיין מעניק לך הרשאות root בתוך הסביבה שלך.

האם המאמר הזה היה מועיל?

#history#computing#virtualization#mainframe#vps