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

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

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

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

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

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

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

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

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

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

צומתי GKE הם מכונות וירטואליות נפרדות של 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. צריך גם קובץ Docker קיים.

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

הפקודות הבאות מניחות שיש לכם מכונה וירטואלית של Arm build ומכונה וירטואלית של x86 build בסביבת ה-build, ושמכונת ה-x86 הווירטואלית יכולה להתחבר ב-SSH כמשתמש root למכונת ה-Arm הווירטואלית. אם יש לכם רק מכונה וירטואלית מסוג x86 בסביבת ה-build, פעלו לפי ההוראות בקטע הבא, הכנת הסביבה אם יש לכם רק מכונה וירטואלית מסוג 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.

הכנת הסביבה אם יש לכם רק מכונה וירטואלית 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