מה זה Multi-Stage Docker?

Multi-שלב Docker בונה הם תכונה שהוצגה ב Docker 17.05 המאפשרת לך להשתמש במספר רב (FLT:0) הצהרות בתוך דוקרפטן יחיד.כל הוראה 1FLT מתחיל שלב חדש, אשר יכול להיות בעל תמונת הבסיס שלו, תלותיות, פקודות.Doifacts יכול להיות העתקה באופן סלקטיבי משלב אחד למשנהו, בעוד התמונה הסופית שומרת רק על מה נדרש עבור שרשראות מורכבות, או להסיר את הסימון.

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

היתרונות של Multi-Stage Builds

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

1 צמצום גודל התמונה

על ידי מחיקת תלות בהקמה, ריבוי שלבים בונה תמונות מתכווץ לעתים קרובות על ידי 50% עד 90%.לדוגמה, יישום Node.js שנבנה באמצעות התמונה המלאהFLT:4 (מעל 300MB) ניתן להפחית עד מתחת 20MB על ידי העתקה רק של FLT:5 תיקיה לבסיס 1000:6.

2 שיפור האבטחה

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

3.הבנה מחדש תהליך

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

4.שיפור הכדאיות והיציבות

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

בניית כרח רב-Stage Dockerfile: Step by Step

זה מסלול מכסה את יצירתו של רב-שלבי בעל שם ייצור עבור Node.js ו- React יישום. אותם עקרונות חלים על כל שפה משותפת.

1.תתכנן את השלבים שלך

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

  • (ב) ,0Builder StageveFLT:1) - מתקין את כל הכלים, מתקין את התלויות, ומפעיל את הפיקוד על הבנייה.
  • (ב) [ה]הבמה של רוצ'י [ב]: [ה], משתמשת בדימוי בסיס מינימלי, עותקים בלבד מהממצאים שנבנו משלב הבנאי, ומגדיר את התנהגות הזמן.

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

2.כתבו את שלב ה-Build

התחל עם תמונה בסיסית הכוללת את שרשרת הכלים הנדרשת:0 שלבים בשם: 1 LT עם FLT 9 כדי להתייחס אליהם מאוחר יותר.

FROM node:14-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
RUN npm run build

נקודות מפתח:

  • השתמש ב-FLT:11 עבור ההתקנה של תלות ⁇ , מהירה יותר.
  • שמור על ה-FLT:12 לפקודות נפרדות ככל האפשר כדי למנף את ה-Chang.
  • התקנת כלים (כמו TypeScript, Webpack) בשלב זה בלבד.

שלב מבחן ביניים (Optional)

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

FROM builder AS test
RUN npm run test

ניתן לנהל שלב זה בצנרת CI שלך עם FLT:14 כדי לתפוס כישלונות מוקדם ללא בניית התמונה הסופית כולה.

Define the Runtime Stage

לקבלת יישום תגובה, התמונה במשרה מלאה יכולה להיות שרת Nginx. עבור API אחורי, זה עשוי להיות תמונה ללא עכבות או מזערית עם Node.js לרוץ זמן. העתק רק את הפריטים החיוניים באמצעות FLT:15.

FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

אם אתה צריך את ה- Node.js לרוץ זמן, להימנע העתקה של ה-FLT:17 מהבנייה; במקום זאת, להתקין מחדש את תלות הייצור בשלב הזמן:

FROM node:14-alpine AS runtime
WORKDIR /app
COPY --from=builder /app/dist ./dist
RUN npm ci --only=production
EXPOSE 3000
CMD ["node", "dist/server.js"]

בנה ובדוק את התמונה

בנו את התמונה הסופית באמצעות הפקודה הסטנדרטית:

docker build -t myapp:latest .

כדי לאמת את הגודל, לרוץ (FLT:20) ולהשוות נגד בניין חד-שלבי. להפעיל את המכולה ולהאשר את היישום מגיב כראוי:

docker run -d -p 8080:80 myapp:latest
curl http://localhost:8080

שיטות טובות ביותר עבור Multi-Stage Builds

  • (ב) ,0) ,הופנה ל[[1924]], [[1924]]]], [[1924]]]]
  • (ב) ויקרא י"ד: "ה' י"א ויקרא י"א ויקרא י"א , ויקרא י"ד , ויקרא י"ד , ויקרא י"ד , ויקרא י"ד , ).
  • (ב) ויקרא י"ד: ויקרא י"ד): "ה', ויקרא י' (ב) ויקרא י"ד)" (בראשית כ"ד, כ"ד).
  • (FLT:0) לדרג שלבים סופיים רבים לסביבות שונות של סביבות חדשות: לדוגמה, שלב פיתוח עם כלים מבולגנים ושלב ייצור עם תמונה מבוססת קשה.
  • (ב) [ה]ב]: [ה] [ה] [ה]] [ה]], [בפיתוח] ניתן לעצור בשלב ה-FLT:30] כדי להשיג עומס חי ומפות מקור, ולאחר מכן לבנות מחדש עם FLT:31 לייצור.
  • (ב) עיין בפסוק "ה': "הוציאו סודות מהתמונות של ⁇ " (שם ב') "אל תשתמשו בדגל Docker BuildKit's flag אם אתם צריכים להעביר את האישורים במהלך הבנייה; לעולם לא לכלול אותם בתמונה הסופית.

שיטות נפוצות ושימוש במקרים

שפות מותאמות (Go, Rust, C++)

עבור בינאריות סטטיות, שלב הריצה יכול להשתמש ב-FLT:33 (תמונה בסיס ריק) רק בינארי ואולי קובץ תצורה מועתקים.

FROM golang:1.20-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o myapp .

FROM scratch
COPY --from=builder /app/myapp /myapp
ENTRYPOINT ["/myapp"]

Python Applications

השתמש שלב בונה עם (FLT:35 כדי להתקין את התלויות ולהפיק כל הרחבה C, ולאחר מכן להעתיק רק את החבילות המותקנות לשלב זמן ריצה:

FROM python:3.11-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --user -r requirements.txt
COPY . .

FROM python:3.11-slim
COPY --from=builder /root/.local /root/.local
COPY --from=builder /app /app
ENV PATH=/root/.local/bin:$PATH
CMD ["python", "app.py"]

שיתוף פעולה עם API Server

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

FROM node:14-alpine AS frontend-builder
WORKDIR /app
COPY frontend/package*.json ./
RUN npm ci
COPY frontend/ .
RUN npm run build

FROM node:14-alpine AS api-builder
WORKDIR /app
COPY api/package*.json ./
RUN npm ci
COPY api/ .
RUN npm run build

FROM node:14-alpine
WORKDIR /app
COPY --from=frontend-builder /app/build ./public
COPY --from=api-builder /app/dist ./dist
RUN npm ci --only=production
EXPOSE 3000
CMD ["node", "dist/server.js"]

פתרון Multi-Stage Builds

  • (ב) ,0) ,לא עבד ב' 1', וודאו כי המצוות צווות לפני קוד המקור.
  • (ב) [17] , עיין ב[[1924]] ב[[1924]], [[1924]], [[1924]], [[1924]]]], [[1924]]]], [[1924]]]]]], [[1924]]]]]]]]
  • [01:0] , ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
  • (ב) עיין בדימויים האחרונים למרות ריבוי שלבים: (ב) עיין אם אתה העתק בטעות FLT:44 או את כל המקור.

מסקנה

Multi-שלב Docker בונה הם אבן הפינה של מיכליזציה מודרנית.הם מאפשרים לך לשלוח תמונות רזה, מאובטח תוך שמירה על תהליך הבנייה פשוט ותיעוד ב-Dockerfile יחיד. על ידי הפרדה בין בנייה וריצה, אתה יכול להפחית באופן דרסטי את גודל התמונה, לשפר את האבטחה, ולייעל צינורות CI /CD.הטכניקות המוצגות כאן חלות כמעט על כל ערימה - בין אם אתה בונה Nodejs, Go Python, פתח, או לבנות את האפליקציות, או להתחיל באופן מיידי, להתחיל, להתחיל, כדי להתחיל מחדש, כדי לשפר את ה-ידי התקנת שיפורים לפני ההתקנה, או להתחיל את ה-D.

לפרטים נוספים, מתייחסים ל-FLT:0 (הידוען דוקר רב-שלבי) בונים תיעוד של ההרחבה 1 (FLT:1 ו-FLT:2Dockerfile Best Practices GuideveFLT:3 Real-worldדוגמאות זמינות גם בתיעוד הספרייה FLT:4Docker Library מתעד FLT:5).