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

מקור ה-VPS שלכם

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

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

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

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

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

מה היה על 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 (יחידת ניהול זיכרון) המעניקה לכל תהליך מרחב כתובות וירטואלי משלו. אחסון ששורד התנתקות הוא ספריית הבית (home directory) שלך. קובץ הסיסמאות עדיין נקרא /etc/passwd.

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

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

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

Multics מסווגת לעיתים קרובות ככישלון כיוון שהגיעה באיחור ופעלה לאט. אוצר המילים הטכני מעיד אחרת. היא העניקה לנו את מערכת הקבצים ההיררכית של ספריות בתוך ספריות, רשימת בקרת גישה (ACL) על כל קובץ, זיכרון וירטואלי מפולח שאפשר לתוכנית להתייחס לקובץ כא

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. חמישים ושתיים שנים לאחר מכן, הממשק הזה הורחב, אך מעולם לא הוחלף.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

FAQ

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

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

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

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

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

הכלל של Popek ו-Goldberg משנת 1974 קובע שכל פקודה שיכולה לקרוא או לשנות את מצב המכונה חייבת לייצר 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 מבוסס מכולות (containers) נמצא בין השניים, כיוון שהוא משתף את ה-kernel של המארח אך עדיין מעניק לך הרשאות root בתוך הסביבה שלך.