ARM VPS לעומת x86 VPS: מה באמת משתנה
מחירי ARM VPS משתנים לפי ספק וחבילה. בדקו אם התשתית שלכם תואמת ל־arm64, אילו images עלולים להיכשל ואילו פקודות מוכיחות זאת לפני הרכישה.
מה משתנה במעבר ל־ARM VPS
ARM VPS מפעיל את אותה מערכת Linux ואת אותו Nginx כמו VPS מבוסס x86. הסיכון במעבר הוא תאימות. תוכנית שהודרה עבור x86-64 אינה יכולה לפעול באופן טבעי על arm64. אמולציה במצב משתמש של QEMU יכולה להפעיל אותה על מעבד ARM, אך הביצועים תלויים בעומס העבודה. לכן, הפעלה טבעית מחייבת שכל רכיב בתשתית התוכנה שלכם יסופק בגרסת arm64, או שיהיה ניתן להדר אותו מחדש.
רוב התשתיות המודרניות עומדות בדרישה זו ללא עבודה נוספת. הכשלים מתרכזים בשני מקומות: images של containers שנבנו אי־פעם עבור ארכיטקטורה אחת בלבד, ותוכנה בקוד סגור שאין לה הורדה עבור arm64. הפקודות שלהלן עונות על שתי השאלות האלה עבור התשתית שלכם, לפני שאתם משלמים על instance. אם אתם עדיין מבררים איזה סוג שרת אתם צריכים, התחילו ב־מהו VPS ובמה הוא שונה מאירוח משותף.
arm64, aarch64, amd64: מה המשמעות של כל שם
הריצו את הפקודות הבאות על כל instance לפני כל פעולה אחרת.
uname -m
dpkg --print-architecture
lscpu | head -n 12
getconf PAGESIZEuname -m מדפיס aarch64 במכונת ARM ו-x86_64 במכונה מבוססת Intel או AMD. dpkg --print-architecture מדפיס arm64 ו-amd64 עבור אותן שתי מכונות. שתי התשובות נכונות. ליבת ה-Linux ומערכת ה-packaging של Debian בחרו שמות שונים לאותה ארכיטקטורת הוראות, לכן aarch64 ו-arm64 מציינים דבר אחד, ו-x86_64 ו-amd64 מציינים את האחר. Docker משתמשת בשמות בסגנון Debian, וזו הסיבה שה-platform של ה-image נקראת linux/arm64.
ב-arm64, תוכנית 64-bit רגילה שקוראת את /proc/cpuinfo לא תקבל שורת model name. הליבה מדפיסה שורה כזו רק כאשר התהליך הקורא רץ תחת מצב תאימות ל-32-bit (PER_LINUX32), וגם אז מדובר במחרוזת ARMv8 Processor rev N גנרית ולא בשם מוצר. קריאה מקורית (native) תציג לכם שדה Features במקום זאת, ורכיבי הצפנה חומרתיים יופיעו שם כדגלים (flags) כמו aes pmull sha1 sha2. אלו הם ה-ARMv8 Cryptographic Extensions, והם מבצעים את העבודה ש-AES-NI מבצע בחלקים של Intel ו-AMD: הם מאיצים חומרתית TLS (transport layer security) והצפנת דיסקים. המדריך בדיקת האצת חומרה מסוג AES ב-VPS מכסה את הבדיקה בשתי הארכיטקטורות.
מדוע קונטיינרים נכשלים תחילה וכיצד נראית השגיאה
כל תצורת image של Docker מתעדת את הארכיטקטורה שעבורה היא נבנתה. אם מושכים tag שאינדקס ה־image שלו מכיל רק מניפסטים של amd64 אל host מסוג arm64, בחירת הפלטפורמה נכשלת עם no matching manifest, אלא אם עוקפים את הפלטפורמה המבוקשת. אם image של amd64 מגיע להפעלת התהליך ללא אמולציה, הכשל נראה כך:
WARNING: The requested image's platform (linux/amd64) does not match the detected host platform (linux/arm64/v8) and no specific platform was requested
exec /usr/local/bin/docker-entrypoint.sh: exec format errorexec format error הוא סירוב של kernel להריץ את הקובץ, משום ש־header ה־ELF שלו (פורמט executable and linkable) מציין סוג מכונה שה־CPU הזה אינו תומך בו. שום הגדרה אינה גורמת ל־CPU להריץ אותו באופן טבעי. ההוראות אינן קיימות במעבד. הדרך היחידה לעקוף זאת היא אמולציה, שבה עוסקים הפסקאות הבאות.
בדקו את המניפסט לפני הפריסה:
docker buildx imagetools inspect nginx:1.27עבור אינדקס image או רשימת מניפסטים, הפלט מציג שורות Platform: כגון linux/amd64 ו־linux/arm64. ל־image של פלטפורמה יחידה אין שורת Platform: בפלט ברירת המחדל; בדקו את התצורה שלו באמצעות docker buildx imagetools inspect <image> --format '{{json .Image}}' וחפשו את "os": "linux" ואת "architecture": "arm64". אם ל־tag אין image של arm64, הוא לא יופעל באופן טבעי על VPS מסוג ARM. Docker דוחה את ה־pull במהלך בחירת הפלטפורמה או, אם image של amd64 מגיע להפעלה ללא אמולציה, ההרצה נכשלת עם exec format error. docker manifest inspect --verbose nginx:1.27 מציג את אותו מידע, אך בתיעוד של Docker מצוין כי docker manifest היא פקודה ניסיונית שהתנהגותה עשויה להשתנות בין גרסאות, לכן העדיפו את imagetools.
עבור images שאתם בונים בעצמכם, בנו את שתי הארכיטקטורות בפקודה אחת ודחפו רשימת מניפסטים:
docker buildx build --platform linux/amd64,linux/arm64 -t registry.example.com/app:1.4 --push .גרסאות BuildKit רשמיות כוללות אמולטורים של QEMU במצב משתמש, לכן בנייה עבור ארכיטקטורה זרה בדרך כלל אינה דורשת התקנה ידנית. אם ל־builder שלכם אין אמולטורים משולבים תקינים, התקינו QEMU ורשמו אותו אצל handler של kernel עבור binfmt_misc:
docker run --privileged --rm tonistiigi/binfmt --install allהשתמשו באמולציה לצורכי build ולבדיקות. אל תשתמשו בה כדי להגיש תעבורת רשת. בתיעוד של Docker עצמו מצוין שאמולציה באמצעות QEMU "עלולה להיות איטית בהרבה מבנייה טבעית, במיוחד במשימות עתירות חישוב כמו קומפילציה ודחיסה או חילוץ". אזהרה זו לגבי ביצועי build אינה קובעת אם שירות שפועל באמולציה משמר את החיסכון בעלות של instance; מדדו את עומס העבודה שלכם. הגדרת ה־host עבור המקרה הטבעי זהה בשתי הארכיטקטורות: הפעלת Docker על VPS עוסקת בכך, וגם קובץ Compose קיים דורש בדיקה של הגדרות ארכיטקטורה כגון platform: linux/amd64, שעדיין מבקשת amd64 גם כאשר image של arm64 זמין. הסירו את העקיפה הזו או שנו אותה ל־platform: linux/arm64 כדי להפעיל arm64 באופן טבעי.
האם החבילות שאני צריך זמינות עבור arm64?
Ubuntu ו־Debian בונות כמעט את כל הארכיון עבור arm64, ולכן apt install nginx postgresql redis-server פועל באותו אופן בשתי הארכיטקטורות. הפערים נמצאים בדרך כלל במאגרים של צד שלישי.
שאלו את apt ישירות, במופע של ARM:
apt-cache policy some-vendor-agent
apt-get install -s some-vendor-agentדיווח של apt-cache policy על Candidate: (none) פירושו של־APT אין מועמד להתקנה תחת תצורת המאגרים וסדרי העדיפויות הנוכחיים. apt-get install -s מדמה את ההתקנה ואינו כותב דבר. חבילה חסרה וחבילה מוכרת שאין לה מועמד להתקנה מפיקות שגיאות שונות.
לאחר מכן קראו את הפלט של apt update במקום לדלג עליו בגלילה. מאגר של ספק שתומך ב־amd64 בלבד יציין זאת:
N: Skipping acquire of configured file 'main/binary-arm64/Packages' as repository 'https://repo.example.com/apt stable InRelease' doesn't support architecture 'arm64'המאגר מוגדר ונגיש, אך אינו מספק אינדקס חבילות arm64 המבוקש. בדקו גם את רשומת המקור עצמה. שורה שמוצמד אליה [arch=amd64] מבקשת אינדקסים של מאגר amd64 גם במארח arm64. היא אינה מדלגת על רשומת המקור ואינה מבקשת אינדקסים של arm64.
אילו עומסי עבודה בטוחים, ואילו דורשים בדיקה מוקדמת
סביבות ריצה מפורשות (interpreted) וסביבות bytecode הן ניידות מעצם תכנונן. ל-PHP, Python, Ruby ו-Node.js יש חבילות arm64 בהפצות הראשיות. Go ו-Rust תומכות ב-cross-compilation ל-arm64. עבור Rust, הפקודה rustup target add מתקינה רק את ספריית הסטנדרט עבור ה-target, לכן בדרך כלל תזדקקו גם ל-linker עבור אותו target. מחסנית LEMP, ממשק API ב-Node, קובץ binary של Go מאחורי Nginx או מסד נתונים Postgres הם עבודה שגרתית ב-arm64.
מהדר Just-in-time (JIT) מייצר קוד מכונה בזמן ריצת התוכנית, לכן הוא זקוק למחולל קוד עבור ארכיטקטורת ה-target. לגרסאות הנוכחיות יש כזה: OpenJDK, .NET, מנוע ה-V8 בתוך Node.js ו-PyPy תומכים כולם ב-arm64 על Linux. גרסאות ישנות ומקובעות הן הסיכון האמיתי. תסריט פריסה (deploy script) שמתקין גרסת runtime מלפני כמה שנים צריך להיבדק מול הערות השחרור של אותה גרסה בנוגע לתמיכה ב-aarch64, במקום להניח שהיא תעבוד.
ספריות המכילות קוד assembly שנכתב ידנית עבור x86, או intrinsics של SSE ו-AVX, הן המקרה השקט יותר. לרוב הספריות יש גם נתיב NEON (NEON היא ארכיטקטורת ה-vector של ARM) או חלופת C פשוטה, כך שהן עוברות הידור ורצות. הביצועים עשויים להיות שונים מה-build של x86 לכאן או לכאן. מדדו זאת על ה-instance שלכם במקום להסיק מסקנות ממאמרים.
תוכנה בקוד סגור היא החסם האמיתי. סוכן ניטור של ספק, דרייבר מסד נתונים ברישיון, לוח בקרה מסחרי או daemon של אנטי-וירוס מגיעים כקובץ binary מהודר, וכאשר הספק לא מפרסם גרסת arm64, לא ניתן להדר אותם מחדש. אמולציית QEMU user mode עדיין יכולה להריץ קובץ binary של x86-64 ב-userspace על ARM, אך הביצועים תלויים בעומס העבודה, והשאלה אם הספק תומך בכך היא נושא נפרד. cPanel ו-WHM הם המקרה הברור ביותר באירוח: דרישות המערכת שלהם מציינות ש-cPanel אינה תומכת במערכות בארכיטקטורת ARM, לכן שרת לוח בקרה נשאר על x86 (נבדק בנובמבר 2026, וכדאי לקרוא שוב בדף הדרישות של הספק). אם זה הדבר היחיד שעוצר אתכם, חלופות cPanel שכדאי להריץ על VPS הוא המקום להתחיל בו, ובדקו את התמיכה בארכיטקטורה של כל אחת מהן באותה דרך.
ליבות וגודל עמודים: היכן מופיעים עדיין הבדלים בין מופעי ARM
שרתי x86-64 כמעט ניתנים להחלפה זה בזה. שרתי ARM אחידים פחות, וההבדלים ביניהם נמצאים מתחת לשכבת היישום.
גודל העמודים הוא ההבדל שמגיע לסביבת הייצור. ברוב ליבות arm64 נעשה שימוש בעמודים בגודל 4 KiB, כמו ב־x86-64. בחלק מהמערכות נעשה שימוש בעמודים בגודל 64 KiB. Red Hat Enterprise Linux 8 עבור aarch64 הגיע עם ליבה שמשתמשת כברירת מחדל בעמודים בגודל 64 KiB, ואילו RHEL 9 החזיר את ברירת המחדל ל־4 KiB, תוך שמירה על חבילת kernel-64k נפרדת עבור עומסי עבודה שזקוקים לגודל הגדול יותר. גודל עמוד של 64 KiB מעלה את צריכת הזיכרון המזערית של תהליך עם מיפויי זיכרון קטנים רבים, משום שהיחידה הקטנה ביותר שהליבה יכולה להקצות גדולה פי 16. הפעילו getconf PAGESIZE על המופע וקראו את הערך, במקום להניח אותו מראש. גודל העמודים אינו החלטת הליבה היחידה שמשפיעה עליכם, משום שהגרסה שספק התשתית מפיץ קובעת גם כיצד העבודה מתוזמנת על הליבות, ו־תזמון מודע למטמון שנוסף ב־Linux 7.2 זמין גם ב־arm64 וגם ב־x86-64.
כדאי להכיר עוד כמה הבדלים קטנים יותר. ב־arm64 אין חבילת microcode למעבד ברמת מערכת ההפעלה, ולכן עדכוני הקושחה מגיעים מספק התשתית ולא מ־apt. שרתי ARM מופעלים באמצעות UEFI (ממשק קושחה מאוחד וניתן להרחבה), ומתארים את החומרה באמצעות ACPI (ממשק תצורה וניהול צריכת חשמל מתקדם). תכונות מסוימות של x86 אינן זמינות ב־ARM, ובהן הצפנת זיכרון AMD SEV ומעבדי GPU מתווכים מסוג Intel GVT-g. ל־ARM יש גישה משלו למחשוב חסוי במקום SEV: Arm CCA, שבו ההרחבה Memory Encryption Contexts מאפשרת לכל Realm להשתמש בהקשר הצפנת זיכרון נפרד.
האם פלטפורמת השרתים של ARM הגיעה לבשלות?
בצד התוכנה, כן. Debian, Ubuntu, Fedora ו-RHEL כולן מפיצות גרסאות arm64 ברמה גבוהה, ותמונות (images) רשמיות ב-Docker Hub הן לרוב multi-arch. עם זאת, סטטוס רשמי אינו ערובה: ה-tags הנוכחיים של ה-Docker Official Image של Percona מפרטים רק את linux/amd64 (נבדק בנובמבר 2026), לכן בדקו כל image בכל מקרה.
הראיה הברורה ביותר לאחרונה היא Proxmox. ב-5 באוגוסט 2026 הכריזה Proxmox על המהדורה הראשונה הנתמכת רשמית ב-arm64 של Proxmox Virtual Environment, גרסה 9.2, החולקת מאגרי חבילות ומחזור חיים של שחרורים עם מהדורת ה-x86-64. הודעת השחרור ציינה שהיא נבנתה על Debian 13.5 עם Linux 7.0, QEMU 11.0, LXC 7.0 ו-ZFS 2.4, והתצורה והכלים תואמים ל-x86-64 מלבד קבוצה קטנה של פריטים ספציפיים לארכיטקטורה.
קראו את ההסתייגויות באותה הודעה, כיוון שהן מראות עד כמה חומרת שרתים נתמכת רשמית ב-ARM עדיין מצומצמת. Proxmox אישרה מערכות NVIDIA Grace ו-NVIDIA Vera ביום הראשון, לאחר בדיקות משותפות עם NVIDIA ו-Supermicro על חומרת Grace Hopper, ושתיים אלו הן הפלטפורמות הנתמכות במלואן. הודעת הפורום של Proxmox מציינת שחומרה אחרת מבוססת UEFI מסוג ARMv9-A או חדשה יותר נתמכת על בסיס "מאמץ מיטבי" (best effort), ועל המארח לעלות דרך UEFI ולתאר את החומרה שלו דרך ACPI. הודעת הפורום מציינת שחומרת ARMv8-A עובדת בדרך כלל, גם היא על בסיס מאמץ מיטבי (נבדק בנובמבר 2026). מחשבים לוח יחיד (SBC) מבוססי Device tree בלבד, כמו Raspberry Pi, אינם נתמכים. אורח (guest) רץ רק על node מאותה ארכיטקטורה, live migration עובד רק בין nodes מאותה ארכיטקטורה, ו-clusters בעלי ארכיטקטורה מעורבת אינם נתמכים רשמית.
זוהי העמדה הכנה נכון לאוגוסט 2026. ספק hypervisor שמשחרר גרסת arm64 באותו מחזור חיים כמו x86-64 הוא התקדמות אמיתית עבור הפלטפורמה. רשימת החומרה הנתמכת ביום הראשון כוללת שתי משפחות מעבדים בלבד.
רשימת בדיקות לביצוע לפני התחייבות
- הפעילו את
uname -mבמופע ניסוי וודאו שהוא מדפיסaarch64. - הפעילו את
docker buildx imagetools inspectעל כל image בקובץ Compose שלכם וודאו שקיימת רשומת פלטפורמה מסוגlinux/arm64ב־image index שלו, או בדקו את התצורה של image בעל פלטפורמה יחידה עבור Linux ו־arm64. בדקו גם אם קיימות בקובץ Compose עקיפות מסוגplatform: linux/amd64. - הפעילו את
apt updateבמופע ARM וקראו כל אזהרתSkipping acquireשהוא מדפיס. - פתחו את דף ההורדות של כל agent בקוד סגור שאתם תלויים בו, וחפשו build מסוג arm64 או aarch64 לפי השם.
- הפעילו את
getconf PAGESIZEורשמו את התשובה לפני שאתם קובעים את כמות הזיכרון. - הריצו benchmark משלכם הן על תוכנית ARM והן על תוכנית x86 שאתם שוקלים.
מה פוסט זה אינו מתיימר לקבוע
איננו מתכוונים לספק לכם יחס עלות-תועלת בין ARM לבין x86. המחירים לכל ליבה משתנים בין ספקיות ובין תוכניות שונות, ומדידה שבוצעה על חומרה של מישהו אחר אינה חוזה את התוצאות אצלכם. במקום זאת, בצעו מדידה בעצמכם. המדריך שלנו לביצוע benchmarking ל-VPS מכסה את sysbench ו-fio בשיטה שתוכלו לשחזר, ו-מה העלות האמיתית של VPS מכסה את הצד הכלכלי של ההשוואה. אחסון הוא החלטה נפרדת מארכיטקטורת ה-CPU, ו-כיצד NVMe בהשוואה ל-SATA SSD ב-VPS עוסק בחלק זה. הריצו את אותה בדיקה על שתי התוכניות, עם עומס העבודה שלכם במידת האפשר, ותנו למספרים שלכם להכריע.
FAQ
האם מכולות Docker שלי יפעלו על VPS מבוסס ARM?
הפעלה טבעית מחייבת תמונת Linux מסוג arm64 לכל שירות והגדרות Compose שבוחרות ב־arm64. בדקו כל תמונה באמצעות docker buildx imagetools inspect <image> וחפשו שורת Platform: linux/arm64 באינדקס התמונות; עבור תמונה של פלטפורמה יחידה, השתמשו ב־--format '{{json .Image}}' ובדקו במקומה את מערכת ההפעלה ואת הארכיטקטורה. תמונות רשמיות רבות ב־Docker Hub תומכות בכמה ארכיטקטורות, אך לא כולן: התגים הרשמיים של התמונה של Percona מציינים רק linux/amd64. גם תמונות של ספקים קטנים יותר, ותמונות שבניתם בעצמכם במכונת x86, לרוב אינן תומכות בכמה ארכיטקטורות. עבור תמונות משלכם, בצעו build באמצעות docker buildx build --platform linux/amd64,linux/arm64 ... --push, כך שתג אחד ישמש את שתי הארכיטקטורות.
מה המשמעות של exec format error בשרת ARM?
ה־kernel ניסה להפעיל קובץ בינארי שכותרת ELF שלו מציינת סוג מכונה אחר, וסירב להפעילו. במארח arm64 משמעות הדבר כמעט תמיד היא קובץ בינארי או תמונת מכולה של x86-64. Docker עשוי לדחות תמונה שאינה תואמת במהלך ה־pull; אם התמונה מגיעה לשלב ההפעלה, Docker עשוי גם להציג אזהרה שלפיה פלטפורמת התמונה המבוקשת linux/amd64 אינה תואמת לפלטפורמת המארח שזוהתה linux/arm64/v8. הפתרון הוא build עבור הארכיטקטורה הנכונה. שום שינוי תצורה לא יגרום לקובץ בינארי של x86-64 לפעול באופן טבעי על ARM.
האם arm64 זהה ל־aarch64?
כן. אלה שני שמות למערכת ההוראות של ARM ב־64 סיביות. ה־kernel מדווח על aarch64 דרך uname -m, ואילו החבילות של Debian ו־Ubuntu ומחרוזות הפלטפורמה של Docker משתמשות ב־arm64. אותו פיצול קיים גם בצד האחר, שבו uname -m מציין x86_64, ואילו במערכת החבילות מצוין amd64. אם בדף ההורדה מוצעים רק קובצי aarch64, אלה הקבצים המתאימים למכונה ש־dpkg --print-architecture מכנה arm64.
האם VPS מבוסס ARM מהיר יותר מ־VPS מבוסס x86?
לשאלה הזאת אין תשובה כללית, וכל יחס יחיד שקראתם עליו נמדד בחומרה שאינה שלכם. המהירות תלויה בדגם ה־CPU הספציפי, במספר הליבות שהוקצו לכם, באופן שבו הספק מנהל תחרות בין דיירים, ובמידת היעילות שבה עומס העבודה שלכם משתמש בהוראות וקטוריות. בצעו benchmark לשתי התוכניות שביניהן אתם באמת בוחרים, באמצעות עומס העבודה שלכם אם הדבר אפשרי, והשוו את המספרים שהתקבלו.
מה עליי לבדוק לפני העברת שרת ייצור ל־arm64?
ארבע בדיקות, בסדר הזה. ודאו שכל תמונת מכולה תומכת ב־Linux arm64, כולל תמונות של פלטפורמה יחידה, וש־Compose בוחר בארכיטקטורה הזאת. ודאו שכל מאגר apt של צד שלישי מספק את החבילות הדרושות לכם עבור arm64, או כחבילות שאינן תלויות בארכיטקטורה. ודאו שכל agent בקוד סגור מספק הורדה של aarch64. לאחר מכן הפעילו getconf PAGESIZE במופע היעד, משום ש־kernel עם דפי זיכרון בגודל 64 KiB משנה את טביעת הזיכרון של תהליכים עם מיפויים קטנים רבים. כל דבר שנכשל באחת מארבע הבדיקות האלה הוא סיבה להשאיר את השרת המסוים הזה על x86.