אתגר ה- Cross-Platform Container

Dockers מבטיחים לכתוב על-once-run-בכל מקום, אך המציאות היא יותר מנומנמת כאשר יעדי הפריסה שלך משתרעים על Windows ו- Linux מארחים.כל משפחה במערכת הפעלה חושפת ממשקי גרעין שונים באופן בסיסי: מיכלים לינוקס תלויים ב- cgroups, שםspaces, ו- Ext4 filesystems, בעוד Windows מכולות דורשות את Windows kernel, Hyper-V-V, ו-NFSform באופן מיידי, , , , , , , או , , , , , , , , קיבולת הפעלה של Windows.

אפשרות זו עולה כי תמונה של מיכל אינה מכונה וירטואלית לחלוטין.הוא חולק את הקרנל של המארח. A Linux משתמשת הקרנל לינוקס של המארח; מיכל Windows משתמש הקרנל של Windows המארח.אין חיקוי או שכבת תרגום מסופקת כברירת מחדל.עבור ארגונים שמנהלים תשתיות היברידיות, זה יוצר צורך דחוף לגישה ממושמעת, כלי-מרוסת לבניית תמונות והפצת עבודה על פני מערכת אקולוגית.

מפעילי צי ומהנדסי פלטפורמה חייבים לאמץ אסטרטגיות כי או לייצר תמונות נפרדות לפלטפורמה או למנף את יכולות ההגשמה הרב-ארכיטקטורה של דוקר להציג התייחסות תמונה אחת אשר פותרת את הגירסה הנכונה לכל מארח.הבחירה תלויה במודל הפריסה שלך, תמיכה במרשם ובגרות CI /CD.

אדריכלות של Windows vs. Linux Images

קרנל קופלינג ו- Base Image Selection

כל תמונה של דוקר מתחילה מתמונה מבוססת בסיס שהיא מבוססת לינוקס (למשל, FLT:0;0) ,FLT:1, FLT:2) או מבוסס Windows (למשל, FLT 3: 3 (FLT 3:0;FLT:4), תמונת הבסיס קובעת את סביבת השימוש בריצה ואת מערכת ספריות זמין לינוקס יכול להיות קטן כמו 5 MB (pine), בעוד ש- Windows יש תכונות של 1.5.

ל-Windows קונטיינר יש גם גרסה קפדנית יותר: תמונת מיכל של Windows שנבנתה עבור אחד מבניית מערכת ההפעלה המארחת (למשל, 20H2) לא יכולה לרוץ על בניין שונה (למשל, 21H2). Microsoft מקטין את זה עם הרעיון של התפלגות:0מעבד בידוד FLT:1 לעומת FLT:2Hyper-V בידוד FLT3, אך התמונה הניתנת להתאמה לאחור לגרסה הדומה יותר ל-APIOSL.

מערכת הקבצים והפרשות

תמונות לינוקס משתמשות באישורים POSIX (משתמש, קבוצה, אחר) ודרכים קובץ רגישות במקרה.תמונות Windows מסתמכות על ACLs (רשימת בקרת גישה) ודרכים רגישות במקרה. הפעלת תמונה לינוקס עם קוד המצפה לטיפול בקובץ רגיש במקרה על מארח Windows (אפילו במיכל) יכול להוביל לחרקים עדינים.

תמונות מרובות-Architecture עם Docker Buildx

כיצד פועלות Buildx

Docker Buildx היא הדרך המומלצת ליצור תמונות שיכולות לרוץ על פלטפורמות מרובות מתוך ייעוד יחיד.זה משתמש חיקוי מבוסס QEMU (עבור לינוקס-on-Linux cross-compilation) או בנאים ילידים על נודים נפרדים כדי ליצור את התמונה עבור כל ארכיטקטורת מטרה. עבור Windows ו- Linux cross-platform בונה, אתה בדרך כלל צריך Windows Native ולבנות nodes, כי QEMU לא יכול לחקות את הליבה של Windows.

בורא עולם מייצר ביטוי רב-ארכיטקטורה (נקרא גם ההרחבה:0) ,1 או FLT:2שומן מפגין התגלותFLT 3:) שמתייחס לדימוי אחד או יותר, כל אחד מתויג עם הפלטפורמה שלו.כאשר משתמש רץ פועל על מכונת Windows, Docker בוחר אוטומטית את הגרסאות של Windows מ-Linux, כל אחד מהם אינו נדרש להחליף את התג ידני.

הקמת בונה עבור Cross-Platform

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

◄ [15]

(ב) .

(ב) .

ברגע שהבנייה מוגדרת, אתה יכול לבנות ולדחוף את ההגשמה בשלב אחד:

(ב) .

הדגל דוחף באופן אוטומטי את התמונות האישיות ואת הרשימה המתבטאת למרשם, אין צורך בהוראות יצירה נוספות.

מגבלות ו-Gochas

  • (FLT:0 Windows-on-Linux cross-compilation אינו אפשרי ל- QEMU כדי לחקות את הקרנל של Windows.You חייב להיות בעל חלונות לבנות צומת נגיש לנהג Buildx.
  • (FLT:0) תמיכה ברישום חובה לכלול רשימות התגלותFIRLT:1 ; רוב הרשומות הגדולות (Docker Hub, AWS ECR, Azure ACR, GitHub Container Registry) תומכות בהם.חלק מהרשומות הפרטיות עשויות לדרוש ממך לאמת תאימות.
  • Layer caching הוא per-platformtureFLT:1] ⁇ שנבנה על צומת לינוקס אינו חל על בניית Windows.תוכנית מפרידה בין השלבים של CI או שימוש במיקום מטמון משותף המכבד את הפלטפורמה.
  • (ב) ⁇ :0) ⁇ ⁇ (ה) ⁇ (ב) ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇

עיצוב Dockerfiles for Cross-Platform

צעדים עם Multi-Stage Builds

במקום לשמור על שני דוקרטים נפרדים לחלוטין, ניתן להשתמש ברעיונות ובולטי-במה על מנת להתמודד עם הבדלים בפלטפורמה בתוך קובץ יחיד.ה-FLT:12 ו-FLT:13 משתנים נקבעים באופן אוטומטי על ידי Buildx כאשר אתה מציין את דגל FLT:14:


ARG BASE_IMAGE
FROM ${BASE_IMAGE} AS base

FROM base AS install-linux
RUN apt-get update && apt-get install -y libfoo

FROM base AS install-windows
RUN powershell -Command Install-Package -Name Foo

FROM install-${TARGETOS} AS final
COPY app /app
CMD ["/app/start"]

בתבנית זו, (FLT:16) פותר את שלב ההתקנה המתאים, ניתן גם להשתמש ב-FLT:17 או (FLT 18) ו- The FLT:19 שלב בוחר את שלב ההתקנה המתאים.

איכות הסביבה וזריקת קונריג

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


ARG TARGETOS
ENV CONFIG_DIR=/etc/myapp
ENV CONFIG_DIR=C:\\ProgramData\\MyApp

עם זאת, להיות זהיר: הדוגמה לעיל הוא מאיור אבל לא יכול לעבוד כפי-is כי ההוראה (FLT:23) מוערכת בבניית זמן, אבל ה-FLT:24 אגורג זמין בבניית זמן לפלטפורמה.You יכול להשתמש "טריק מדרגה" עם תסריט מותני פלטפורמה או תבנית של בניית זמן.

קו נחיתה ו-Instable Bits

לינוקס מצפה לסילוק קו LF בקבצי פגז ותצורה; Windows משתמש ב-CRLF. בעת בדיקת קבצים לתוך רצף Git, להגדיר FLT:26 לאחסן תסריטים כ-LF וממיר על צ'ק רק עבור מארחי Windows. in the Dockerfile, לסמן באופן מפורש תסריטי כניסה כמפורט ב-FLT:27 (לינוקס) או להשתמש ב-F רק כדי לבנות פלטפורמות זהות על קידוד זהה הן על ידי .

שילוב CI/CD

מטריקס בונה לכל פלטפורמה

ב GitHub Actions, GitLab CI, או Azure Pipelines, השתמש באסטרטגיה ממטריקס לבנות ולבדוק את התמונה על לינוקס ו- Windows רץ בריכות בנפרד.לאחר כל בניין, לדחוף את התמונה הספציפית של הפלטפורמה למרשם עם תג הכולל את suffix הפלטפורמה (למשל, FLT:29, FLT:30).

דוגמה: GitHub Actionsflow (Simplified)


jobs:
 build:
 strategy:
 matrix:
 os: [ubuntu-latest, windows-latest]
 include:
 - os: ubuntu-latest
 platform: linux/amd64
 - os: windows-latest
 platform: windows/amd64
 runs-on: ${{ matrix.os }}
 steps:
 - uses: actions/checkout@v4
 - name: Build and push
 uses: docker/build-push-action@v5
 with:
 platforms: ${{ matrix.platform }}
 tags: myapp:${{ matrix.platform }}-${{ github.sha }}
 push: true

 manifest:
 needs: build
 runs-on: ubuntu-latest
 steps:
 - uses: docker/setup-buildx-action@v3
 - name: Create manifest list
 run: |
 docker buildx imagetools create \
 -t myregistry.io/myapp:latest \
 myregistry.io/myapp:linux-amd64-${{ github.sha }} \
 myregistry.io/myapp:windows-amd64-${{ github.sha }}

בדיקות בשני הפלטפורמות

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

(FLT:0)Tip:cioFLT:1) השתמש ב-FLT:32 כדי לכפות גרסה מסוימת של פלטפורמה מסוימת במהלך בדיקות מקומיות.זה בלתי חוקי כאשר יש לך רק לינוקס עבודה, אבל רוצה לאמת את המבנה המתבטא לפני ביצוע.

בעיות צלב-פלטופור

מצבי כישלון נפוצים

  • (FLT:0) תמונות שגויות של שיבושFLT:1: גרסת Windows Server Core (למשל, ltsc2022 לעומת ltsc2019) אינה תואמת את גרסת מערכת ההפעלה המארחת.תמיד לסמן תג ספציפי של Windows ולתאם עם צוות התשתית שלך.
  • (FLT:0) מגבלות זיכרון ופרמטרי גרעין: מיכלי Windows עשויים לדרוש בידוד Hyper-V לאכיפת גבולות זיכרון, בעוד מיכלי לינוקס יכולים להשתמש ב-CFS (לוח זמנים הוגן באופן מלא) אם היישום שלך צופה דפים ענקיים או הגדרות סינקל ספציפיות, אלה הם לינוקס בלבד.
  • (FLT:0Networking DifferencesFLT:1: מיכלי Windows משתמשים מתג מבוסס NAT על ידי ברירת מחדל, וחייב הנמל מתנהג אחרת.FLT:33 אינו נתמך על Windows.
  • (ב) ⁇ :0 (לא) ⁇ (ב) ו-[[1924]], לא [17], אלא אם כן, אין צורך ב-[[1924]], אלא אם כן, ב[[1924]], [[1924]], [[1924]], [[1924]]]]]], [[1924]]]]]]

כלים לרישום ו Introspection

כאשר מדובר בפרשת תפוצה, השתמשו ב-FLT:35 כדי לאמת את מערכת ההפעלה והאדריכלות של התמונה.

[22: 29]

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

(ב) .

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

תבניות אמיתיות בעולם ומלכודות

המונחים: Using Docker Desktop for Local Development

Docker Desktop ב- Windows יכול לעבור בין מצבי לינוקס ו- Windows, אך לא יכול לרוץ בו זמנית.עבור פיתוח חוצה פלטפורמות, להשתמש בבניינים מרוחקים נפרדים או מכונות וירטואליות.היכולת של Docker לנהל מכולות לינוקס (באמצעות WSL 2) הפחיתה את הצורך ב- Windows מכולות על רכיבי מפתח, אך עדיין צריך מיכלים של Windows לשילוב של תכונות תמונה בלבד.

תמונה: LTS Alignment for Windows Images

Microsoft משחררת גרסה חדשה של ערוץ ארוך טווח (LTSC) של Windows Server בערך כל שנתיים עד שלוש שנים.לכל גרסה LTSC יש תמונה של בסיס מיכל המתאים, אם תמונת המכולה שלך מטרות ל- ltsc2022, עליך לבנות אותו על ltsc2022 מארחת (אך לא תוכל להמשיך את התמונה הישנה של Microsoft) אך לא תוכל להמשיך ולפתור אותה עם תמונה חדשה לגמרי, אך לא תוכל להמשיך ולפתור אותה עם קובץ לינוקס חדש, אך לא זמין עם תמונה חדשה, אך לא זמין עם תכונות ישנות יותר, אך עדיין.

ממזר: התעלמות מ-ARM64

בעוד שהמאמר מתמקד ב-Windows ולינוקס, העתיד של מחשוב הוא heterogeneous: AWS Graviton, Azure Ampere, Apple Silicon, ו- Raspberry Pi אשכולs כל לרוץ ARM64 Linux.אם אתה בונה תמונה רב-architecture עבור Windows ולינוקס, לשקול גם כולל FLT:43 במניפסט שלך.

פיט: Overlook Filesystem Permissions in COPY

כאשר משתמשים ב-FLT:44 ב-Docker מכבד את metadata של מערכת הקבצים של המארח המקור.אם אתה COPY תסריט ממארח לינוקס, הוא שומר על מעטה המנוצל ו-LF שורה מסתיימת.If you COPY מ- Windows מארח, הקובץ ללא exeable bit ו-CRLFs כדי להבטיח התנהגות עקבית, FLTY להוסיף קבצים רגילים, לאחר מכן, ולוודא את קוד פתוח ל-J.

מסקנה

ניהול תמונות דו-כוכביות של Windows ו-Linux תאימות כבר אינו מקרה שימוש אקזוטי.זה דרישה מעשית עבור כל צי המשתרע על תשתיות heterogeneous, מ-premises Windows Server אשכולs ל- cloud-native Linux Kubernetes. על ידי אימוץ Dockerx עבור ריבוי-architec מתבטאויות, שמירה על דופורציות תנאי, שילוב של תאים חד-CD-מסלוליים, הן יכולות לספק תמונות מטבוליות ו-CD-מחדשות על פני , הן יכולות לספק את ה-מסלולאריות, הן על פני צי שלם.

ה-EP המרכזי הוא פשוט:

  • השתמש ב-FLT:47 עם Windows ו- Linux לבנות צמתים כדי לייצר רשימות הגשמה.
  • עיין ב[[המאה ה-20]] ו[[1924]]
  • בונה ובדיקות ספציפיות של פלטפורמה אוטומטית ב- CI; רק מתמזגים מתבטאים לאחר שני המעבר.
  • הישארו נוכחיים עם מחזורי שחרור LTSC של Microsoft כדי למנוע תקלות בדימוי הבסיס.

(ב) עם שיטות אלה במקום, ניתן להתמקד באספקת ערך יישומים ולא היאבקות עם פלטפורמה במיומנות.לקריאה נוספת, להתייעץ עם ה-FLT:0Docker Multi-platform לבנות תיעוד של ההרחבה 1:1, ה-FLT:2 Windows מכולות סקירה על Microsoft LearnFLT 3: ו-FLT:4Build מחדשposiLTF:5 עבור תצורה מתקדמת של משאבים להעמיק את המשאבים שלך.