יצירת תמונות מרובות ארכיטקטורות לעומסי עבודה של Arm

טייס אוטומטי רגילה

בדף הזה מוסבר מהן תמונות מרובות ארכיטקטורות (multi-arch), למה הארכיטקטורות של הצמתים ותמונות הקונטיינרים חשובות, ולמה תמונות מרובות ארכיטקטורות מקלות על פריסת עומסי עבודה באשכולות GKE. בדף הזה מוסבר גם איך לבדוק אם עומסי העבודה שלכם מוכנים להרצה ב-Arm, ואיך ליצור תמונות מרובות ארכיטקטורות.

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

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

מהי תמונה מרובת ארכיטקטורות?

תמונה מרובת ארכיטקטורות היא תמונה שיכולה לתמוך בכמה ארכיטקטורות. נראה שזו תמונה אחת עם תג אחד, אבל זו רשימה של תמונות שמטרגטות כמה ארכיטקטורות, מאורגנות לפי רשימת מניפסט. תמונות מרובות ארכיטקטורות תואמות לסכימת Docker Image Manifest V2 Scheme 2 או למפרטי OCI Image Index. כשפורסים תמונה מרובת ארכיטקטורות באשכול, GKE בוחר באופן אוטומטי את התמונה הנכונה שתואמת לארכיטקטורה של הצומת שבו היא נפרסת. אחרי שיש לכם תמונה מרובת ארכיטקטורות לעומס עבודה, אתם יכולים לפרוס את עומס העבודה הזה בצורה חלקה בכמה ארכיטקטורות.

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

אם אתם משתמשים בתמונה עם ארכיטקטורה יחידה או בתמונה עם ארכיטקטורות מרובות שתואמת ל-Arm, ואתם רוצים לפרוס אותה לצומת Arm, אתם צריכים לפעול לפי ההוראות כדי לכלול את השדות הנדרשים, כך שמערכת GKE תתזמן את עומס העבודה כמצופה. מידע נוסף זמין במאמר הכנת עומס עבודה של Arm לפריסה. אין צורך להוסיף את השדות האלה לתזמון עומסי עבודה אם עומסי העבודה מתוזמנים רק לצמתים מבוססי x86.

למה הארכיטקטורה של צומת GKE חשובה לעומסי עבודה?

צמתי GKE הם מכונות וירטואליות (VM) נפרדות של Compute Engine שנוצרות ומנוהלות על ידי GKE בשמכם. כל צומת הוא מסוג מכונה לשימוש סטנדרטי (standard) (לדוגמה, t2a-standard-1) שמשתמש במעבדי x86 (Intel או AMD) או Arm. מידע נוסף זמין במאמר בנושא פלטפורמות CPU.

צריך להשתמש בקובצי אימג' של קונטיינרים שתואמים לארכיטקטורה של הצומת שבו רוצים להריץ את עומסי העבודה. לדוגמה, אם רוצים להריץ קובץ אימג' של קונטיינר עם ארכיטקטורת arm64, צריך להשתמש בסוג מכונה שתומך בעומסי עבודה של Arm, כמו t2a-standard-1 מסדרת המכונות Tau T2A. אפשר להשתמש בצמתים עם כמה סוגי ארכיטקטורה באותו אשכול GKE. אם רוצים להשתמש בעומס עבודה אחד בכמה סוגי ארכיטקטורה, צריך לשמור על סדר בכל תמונות הקונטיינרים וקבצי הפריסה של התמונות הספציפיות לארכיטקטורה. תמונות מרובות ארכיטקטורות מפשטות את תהליך הפריסה בסוגי ארכיטקטורות שונים.

יצירת קובץ אימג' מרובה ארכיטקטורות לפריסה בצמתי x86 ו-Arm

אזהרה: ההוראות הבאות מספקות הנחיות לבדיקת מוכנות ל-Arm ולבניית תמונות מרובות ארכיטקטורות. בדוגמאות האלה נעשה שימוש בכלים לא נתמכים של צד שלישי, שיכולים להשתנות בכל שלב ללא הודעה מוקדמת מ-GKE.

ההוראות הבאות מיועדות למפתחי אפליקציות שכבר יש להם:

• סביבת build עם כלי קונטיינר שהורד (לדוגמה, Docker).
• קובץ אימג' קיים של קונטיינר.

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

האם עומס העבודה שלי מוכן ל-Arm?

אם יש לכם קובץ אימג' של קונטיינר קיים, אתם יכולים לבדוק אם עומס העבודה הזה מוכן להרצה בצומת Arm. בקטעים הבאים מוסבר איך עושים את זה באמצעות docker run כדי לנסות להפעיל את מאגר התגים עם ארכיטקטורת Arm.

הכנת Docker בסביבת x86 לבדיקת קובץ אימג' של קונטיינר

אם אתם מריצים את Docker בסביבת x86, אתם צריכים להוריד חבילות נוספות כדי להריץ קובץ אימג' של קונטיינר של arm64. בהוראות האלה נעשה שימוש ב-apt לניהול חבילות, אבל אתם יכולים להשתמש במנהל החבילות של הסביבה שלכם כדי להוריד את החבילות הנדרשות.

אם אתם מריצים Docker בסביבת Arm, אתם יכולים לדלג על הקטע הזה.

הפקודות הבאות מורידות חבילות ורושמות את QEMU כמפענח binfmt לארכיטקטורות שהמחשב שלכם לא תומך בהן:

sudo apt-get install qemu binfmt-support qemu-user-static
docker run --rm --privileged multiarch/qemu-user-static --reset -p yes

אחרי שמגדירים את מנתחי ה-binfmt, אפשר להריץ את תמונת arm64 בסביבת x86.

בדיקת עומס העבודה לצורך מוכנות ל-Arm

אם אתם מריצים את Docker בסביבת Arm, או שהכנתם את סביבת x86 להרצת תמונות Arm, מריצים את הפקודה הבאה:

docker run --platform linux/arm64 IMAGE_NAME

מחליפים את IMAGE_NAME בשם של קובץ אימג' של קונטיינר.

הפלט הבא מציין שקובץ האימג' של הקונטיינר מוכן להפעלה בצמתי Arm באשכול GKE:

Hello from Docker!
This message shows that your installation appears to be working correctly.

אם עומס העבודה שלכם מוכן להרצה ב-Arm, אתם יכולים להמשיך אל הכנת עומס עבודה ב-Arm לפריסה.

הפלט הבא מציין שהתמונה לא מוכנה להרצה ב-Arm:

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
93288797bd35: Pull complete
Digest: sha256:507ecde44b8eb741278274653120c2bf793b174c06ff4eaa672b713b3263477b
Status: Downloaded newer image for hello-world:latest
standard_init_linux.go:219: exec user process caused: exec format error

הפלט הזה מציין שמדובר בתמונה מסוג x86_64 או amd64, ולכן צריך ליצור תמונה מסוג arm64. אפשר לעבור לקטע הבא, יצירת קובץ אימג' עם תמיכה בכמה ארכיטקטורות, שבו אפשר להשתמש בקובץ אימג' של קונטיינר שלא תואם ל-Arm, בקובץ Dockerfile וליצור קובץ אימג' עם תמיכה בכמה ארכיטקטורות שיכול לפעול בסוגים שונים של ארכיטקטורות.

יצירת תמונה מרובת ארכיטקטורות

אם יש לכם Dockerfile, אתם יכולים להשתמש בו כדי ליצור קובץ אימג' מרובה ארכיטקטורות שתואם ל-Arm ול-x86, שאפשר לפרוס אותו בצמתים עם סוגים שונים של ארכיטקטורות.

כדי לבצע את השלבים הבאים, צריך להוריד את Docker Buildx. צריך גם שיהיה לכם Dockerfile קיים.

הכנת הסביבה אם יש לכם מכונה וירטואלית x86 ומכונה וירטואלית Arm

הפקודות הבאות מניחות שיש לכם מכונה וירטואלית של Arm build ומכונה וירטואלית של x86 build בסביבת ה-build, ושמכונת ה-x86 הווירטואלית יכולה להתחבר ב-SSH כמשתמש root למכונת ה-Arm הווירטואלית. אם יש לכם רק VM מסוג x86 בסביבת build, צריך לפעול לפי ההוראות שבקטע הבא, הכנת הסביבה אם יש לכם רק VM מסוג x86.

מכינים את הסביבה ליצירת קובצי אימג' מרובי-ארכיטקטורה:

1. יוצרים הקשר לצומת x86 באמצעות השקע המקומי, והקשר לצומת Arm באמצעות SSH:‏

    docker context create amd_node --docker "host=unix:///var/run/docker.sock"
    docker context create arm_node --docker "host=ssh://root@NODE_IP"
   

   מחליפים את NODE_IP בכתובת ה-IP של צומת Arm.

2. יוצרים builder באמצעות צומת x86:

   docker buildx create --use --name BUILDER_NAME --platform linux/amd64 amd_node
   docker buildx create --append --name BUILDER_NAME --platform linux/arm64 arm_node
   

   מחליפים את BUILDER_NAME בשם שבוחרים ל-builder של Buildx.

הכנת הסביבה אם יש לכם רק מכונת VM מסוג x86

אם יש לכם רק מכונת VM מסוג x86 בסביבת ה-build, אתם יכולים לבצע את השלבים הבאים כדי להכין את הסביבה ליצירת קובצי אימג' מרובי-ארכיטקטורה. אם בוחרים באפשרות הזו, יכול להיות ששלב הבנייה יימשך זמן רב יותר.

1. מתקינים חבילות QEMU:

   docker run --rm --privileged multiarch/qemu-user-static
   

2. יוצרים builder עם תמיכה בכמה ארכיטקטורות (ה-builder שמוגדר כברירת מחדל לא תומך בכמה ארכיטקטורות):

   docker buildx create --name BUILDER_NAME --use
   

   מחליפים את BUILDER_NAME בשם שבוחרים ל-builder של Buildx.

יצירת התמונה

עכשיו, כשהסביבה מוכנה, מריצים את הפקודה הבאה כדי ליצור קובץ אימג' מרובה ארכיטקטורות:

docker buildx build . -t PATH_TO_REGISTRY  --platform linux/amd64,linux/arm64 --push

מחליפים את PATH_TO_REGISTRY בנתיב למרשם, שמסתיים בשם של קובץ אימג' של קונטיינר ובתווית (לדוגמה, gcr.io/myproject/myimage:latest).

אם מופיעה הודעת שגיאה בשלב הזה, אפשר לעיין במדריך ל-Docker ובמסמכים שקשורים אליו כדי לפתור את הבעיה.

אחרי שיוצרים קובץ אימג' מרובה ארכיטקטורות, עומס העבודה מוכן להרצה ב-Arm. ממשיכים אל הכנת עומס עבודה של Arm לפריסה.

המאמרים הבאים

• הכנת עומס עבודה של Arm לפריסה
• העברת אפליקציית x86 ב-GKE לארכיטקטורה מרובת ליבות עם Arm