כמה טיפים כיצד להאיץ את בניית תמונות Docker. לדוגמה, עד 30 שניות

לפני שפיצ'ר נכנס להפקה, בימים אלה של מתזמרים מורכבים ו-CI/CD, יש דרך ארוכה לעבור מהתחייבות לבדיקות והגשה. בעבר, יכולת להעלות קבצים חדשים באמצעות FTP (אף אחד לא עושה את זה יותר, נכון?), ותהליך ה"פריסה" לקח שניות. כעת עליך ליצור בקשת מיזוג ולהמתין זמן רב עד שהתכונה תגיע למשתמשים.

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

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

אנו פורסים ל-GitLab. אנחנו אוספים תמונות, דוחפים אותן ל-GitLab Registry ומגלגלים אותן לייצור. הדבר הארוך ביותר ברשימה זו הוא הרכבת תמונות. לדוגמה: ללא אופטימיזציה, כל בניית backend ארכה 14 דקות.

בסוף התברר שאנחנו כבר לא יכולים לחיות ככה, והתיישבנו להבין למה לוקח כל כך הרבה זמן לאסוף את התמונות. כתוצאה מכך, הצלחנו לצמצם את זמן ההרכבה ל-30 שניות!

למאמר זה, כדי לא להיות קשור לסביבת Reminder, בואו נסתכל על דוגמה להרכבת אפליקציה Angular ריקה. אז בואו ניצור את האפליקציה שלנו:

ng n app

הוסף לזה PWA (אנחנו מתקדמים):

ng add @angular/pwa --project app

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

FROM node:12.16.2
WORKDIR /app
COPY . .
RUN npm ci
RUN npm run build --prod

Dockerfile הוא קבוצה של הוראות; על ידי ביצוע כל אחד מהם, Docker ישמור את השינויים במערכת הקבצים ויכסה אותם על הקודמים. כל צוות יוצר את השכבה שלו. והתמונה המוגמרת היא שכבות משולבות יחד.

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

1. אנו מוחקים את התמונות באופן מקומי כדי שהריצות קודמות לא ישפיעו על הבדיקה.
   docker rmi $(docker images -q)
2. אנחנו משיקים את ה-build בפעם הראשונה.
   time docker build -t app .
3. אנו משנים את הקובץ src/index.html - אנו מחקים את עבודתו של מתכנת.
4. אנחנו מפעילים את הבנייה בפעם השנייה.
   time docker build -t app .

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

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

$ time docker build -t app .
Sending build context to Docker daemon 409MB
Step 1/5 : FROM node:12.16.2
Status: Downloaded newer image for node:12.16.2
Step 2/5 : WORKDIR /app
Step 3/5 : COPY . .
Step 4/5 : RUN npm ci
added 1357 packages in 22.47s
Step 5/5 : RUN npm run build --prod
Date: 2020-04-16T19:20:09.664Z - Hash: fffa0fddaa3425c55dd3 - Time: 37581ms
Successfully built c8c279335f46
Successfully tagged app:latest

real 5m4.541s
user 0m0.000s
sys 0m0.000s

אנו משנים את התוכן של src/index.html ומפעילים אותו פעם שנייה.

$ time docker build -t app .
Sending build context to Docker daemon 409MB
Step 1/5 : FROM node:12.16.2
Step 2/5 : WORKDIR /app
 ---> Using cache
Step 3/5 : COPY . .
Step 4/5 : RUN npm ci
added 1357 packages in 22.47s
Step 5/5 : RUN npm run build --prod
Date: 2020-04-16T19:26:26.587Z - Hash: fffa0fddaa3425c55dd3 - Time: 37902ms
Successfully built 79f335df92d3
Successfully tagged app:latest

real 3m33.262s
user 0m0.000s
sys 0m0.000s

כדי לראות אם יש לנו את התמונה, הפעל את הפקודה docker images:

REPOSITORY   TAG      IMAGE ID       CREATED              SIZE
app          latest   79f335df92d3   About a minute ago   1.74GB

לפני הבנייה, docker לוקח את כל הקבצים בהקשר הנוכחי ושולח אותם לדמון שלו Sending build context to Docker daemon 409MB. ההקשר של build מצוין כארגומנט האחרון לפקודת build. במקרה שלנו, זו הספרייה הנוכחית - ".", - ו- Docker גורר את כל מה שיש לנו בתיקייה הזו. 409 מגה-בייט זה הרבה: בוא נחשוב איך לתקן את זה.

צמצום ההקשר

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

.git
/node_modules

והפעל את ה-build שוב:

$ time docker build -t app .
Sending build context to Docker daemon 607.2kB
Step 1/5 : FROM node:12.16.2
Step 2/5 : WORKDIR /app
 ---> Using cache
Step 3/5 : COPY . .
Step 4/5 : RUN npm ci
added 1357 packages in 22.47s
Step 5/5 : RUN npm run build --prod
Date: 2020-04-16T19:33:54.338Z - Hash: fffa0fddaa3425c55dd3 - Time: 37313ms
Successfully built 4942f010792a
Successfully tagged app:latest

real 1m47.763s
user 0m0.000s
sys 0m0.000s

607.2 KB הוא הרבה יותר טוב מ-409 MB. הקטנו גם את גודל התמונה מ-1.74 ל-1.38 GB:

REPOSITORY   TAG      IMAGE ID       CREATED         SIZE
app          latest   4942f010792a   3 minutes ago   1.38GB

בואו ננסה להקטין את גודל התמונה עוד יותר.

אנחנו משתמשים באלפין

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

$ docker images -a | grep node
node 12.16.2 406aa3abbc6c 17 minutes ago 916MB

... כמעט גיגה-בייט. אתה יכול להפחית משמעותית את עוצמת הקול על ידי שימוש בתמונה המבוססת על Alpine Linux. Alpine הוא לינוקס קטן מאוד. תמונת הדוקר עבור nodejs המבוססת על אלפיין שוקלת רק 88.5 מגה-בייט. אז בואו נחליף את התדמית התוססת שלנו בבתים:

FROM node:12.16.2-alpine3.11
RUN apk --no-cache --update --virtual build-dependencies add 
    python 
    make 
    g++
WORKDIR /app
COPY . .
RUN npm ci
RUN npm run build --prod

היינו צריכים להתקין כמה דברים הדרושים לבניית האפליקציה. כן, Angular לא בונה בלי Python ¯(°_o)/¯

אבל גודל התמונה ירד ל-150 MB:

REPOSITORY   TAG      IMAGE ID       CREATED          SIZE
app          latest   aa031edc315a   22 minutes ago   761MB

בואו נלך אפילו רחוק יותר.

הרכבה רב שלבית

לא כל מה שנמצא בתמונה הוא מה שאנחנו צריכים בהפקה.

$ docker run app ls -lah
total 576K
drwxr-xr-x 1 root root 4.0K Apr 16 19:54 .
drwxr-xr-x 1 root root 4.0K Apr 16 20:00 ..
-rwxr-xr-x 1 root root 19 Apr 17 2020 .dockerignore
-rwxr-xr-x 1 root root 246 Apr 17 2020 .editorconfig
-rwxr-xr-x 1 root root 631 Apr 17 2020 .gitignore
-rwxr-xr-x 1 root root 181 Apr 17 2020 Dockerfile
-rwxr-xr-x 1 root root 1020 Apr 17 2020 README.md
-rwxr-xr-x 1 root root 3.6K Apr 17 2020 angular.json
-rwxr-xr-x 1 root root 429 Apr 17 2020 browserslist
drwxr-xr-x 3 root root 4.0K Apr 16 19:54 dist
drwxr-xr-x 3 root root 4.0K Apr 17 2020 e2e
-rwxr-xr-x 1 root root 1015 Apr 17 2020 karma.conf.js
-rwxr-xr-x 1 root root 620 Apr 17 2020 ngsw-config.json
drwxr-xr-x 1 root root 4.0K Apr 16 19:54 node_modules
-rwxr-xr-x 1 root root 494.9K Apr 17 2020 package-lock.json
-rwxr-xr-x 1 root root 1.3K Apr 17 2020 package.json
drwxr-xr-x 5 root root 4.0K Apr 17 2020 src
-rwxr-xr-x 1 root root 210 Apr 17 2020 tsconfig.app.json
-rwxr-xr-x 1 root root 489 Apr 17 2020 tsconfig.json
-rwxr-xr-x 1 root root 270 Apr 17 2020 tsconfig.spec.json
-rwxr-xr-x 1 root root 1.9K Apr 17 2020 tslint.json

עם docker run app ls -lah השקנו מיכל המבוסס על התמונה שלנו app וביצע בו את הפקודה ls -lah, ולאחר מכן השלימה המכולה את עבודתה.

בייצור אנחנו צריכים רק תיקייה dist. במקרה זה, איכשהו צריך לתת את הקבצים בחוץ. אתה יכול להפעיל שרת HTTP כלשהו ב-nodejs. אבל אנחנו נעשה את זה יותר קל. נחשו מילה רוסית שיש לה ארבע אותיות "y". ימין! Ynzhynyksy. בואו ניקח תמונה עם nginx, נכניס לתוכה תיקיה dist ותצורה קטנה:

server {
    listen 80 default_server;
    server_name localhost;
    charset utf-8;
    root /app/dist;

    location / {
        try_files $uri $uri/ /index.html;
    }
}

בנייה מרובה שלבים תעזור לנו לעשות את כל זה. בואו נשנה את ה-Dockerfile שלנו:

FROM node:12.16.2-alpine3.11 as builder
RUN apk --no-cache --update --virtual build-dependencies add 
    python 
    make 
    g++
WORKDIR /app
COPY . .
RUN npm ci
RUN npm run build --prod

FROM nginx:1.17.10-alpine
RUN rm /etc/nginx/conf.d/default.conf
COPY nginx/static.conf /etc/nginx/conf.d
COPY --from=builder /app/dist/app .

עכשיו יש לנו שתי הוראות FROM ב-Dockerfile, כל אחד מהם מריץ שלב בנייה שונה. התקשרנו לראשון builder, אבל החל מה-FROM האחרון, התמונה הסופית שלנו תוכנה. השלב האחרון הוא להעתיק את החפץ של ההרכבה שלנו בשלב הקודם לתמונה הסופית עם nginx. גודל התמונה ירד משמעותית:

REPOSITORY   TAG      IMAGE ID       CREATED          SIZE
app          latest   2c6c5da07802   29 minutes ago   36MB

בואו נריץ את הקונטיינר עם התמונה שלנו ונוודא שהכל עובד:

docker run -p8080:80 app

באמצעות האפשרות -p8080:80, העברנו את יציאה 8080 במחשב המארח שלנו ליציאה 80 בתוך הקונטיינר שבו פועל nginx. פתוח בדפדפן http://localhost:8080/ ואנחנו רואים את הבקשה שלנו. הכל עובד!

הקטנת גודל התמונה מ-1.74 ג'יגה-בייט ל-36 מגה-בייט מפחיתה משמעותית את הזמן שלוקח לספק את האפליקציה שלך לייצור. אבל בואו נחזור לזמן ההרכבה.

$ time docker build -t app .
Sending build context to Docker daemon 608.8kB
Step 1/11 : FROM node:12.16.2-alpine3.11 as builder
Step 2/11 : RUN apk --no-cache --update --virtual build-dependencies add python make g++
 ---> Using cache
Step 3/11 : WORKDIR /app
 ---> Using cache
Step 4/11 : COPY . .
Step 5/11 : RUN npm ci
added 1357 packages in 47.338s
Step 6/11 : RUN npm run build --prod
Date: 2020-04-16T21:16:03.899Z - Hash: fffa0fddaa3425c55dd3 - Time: 39948ms
 ---> 27f1479221e4
Step 7/11 : FROM nginx:stable-alpine
Step 8/11 : WORKDIR /app
 ---> Using cache
Step 9/11 : RUN rm /etc/nginx/conf.d/default.conf
 ---> Using cache
Step 10/11 : COPY nginx/static.conf /etc/nginx/conf.d
 ---> Using cache
Step 11/11 : COPY --from=builder /app/dist/app .
Successfully built d201471c91ad
Successfully tagged app:latest

real 2m17.700s
user 0m0.000s
sys 0m0.000s

שינוי סדר השכבות

שלושת הצעדים הראשונים שלנו נשמרו במטמון (רמז Using cache). בשלב הרביעי, כל קבצי הפרויקט מועתקים ובשלב החמישי מותקנות תלות RUN npm ci - עד 47.338 שניות. למה להתקין מחדש תלות בכל פעם אם הם משתנים לעתים רחוקות מאוד? בואו נבין למה הם לא נשמרו במטמון. הנקודה היא ש-Docker יבדוק שכבה אחר שכבה כדי לראות אם הפקודה והקבצים המשויכים אליה השתנו. בשלב הרביעי, אנו מעתיקים את כל הקבצים של הפרויקט שלנו, וביניהם, כמובן, ישנם שינויים, כך ש-Docker לא רק שלא לוקח את השכבה הזו מהמטמון, אלא גם את כל הקבצים הבאים! בואו נעשה כמה שינויים קטנים ב- Dockerfile.

FROM node:12.16.2-alpine3.11 as builder
RUN apk --no-cache --update --virtual build-dependencies add 
    python 
    make 
    g++
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build --prod

FROM nginx:1.17.10-alpine
RUN rm /etc/nginx/conf.d/default.conf
COPY nginx/static.conf /etc/nginx/conf.d
COPY --from=builder /app/dist/app .

ראשית, package.json ו-package-lock.json מועתקים, לאחר מכן מותקנים תלות, ורק לאחר מכן כל הפרוייקט מועתק. כתוצאה:

$ time docker build -t app .
Sending build context to Docker daemon 608.8kB
Step 1/12 : FROM node:12.16.2-alpine3.11 as builder
Step 2/12 : RUN apk --no-cache --update --virtual build-dependencies add python make g++
 ---> Using cache
Step 3/12 : WORKDIR /app
 ---> Using cache
Step 4/12 : COPY package*.json ./
 ---> Using cache
Step 5/12 : RUN npm ci
 ---> Using cache
Step 6/12 : COPY . .
Step 7/12 : RUN npm run build --prod
Date: 2020-04-16T21:29:44.770Z - Hash: fffa0fddaa3425c55dd3 - Time: 38287ms
 ---> 1b9448c73558
Step 8/12 : FROM nginx:stable-alpine
Step 9/12 : WORKDIR /app
 ---> Using cache
Step 10/12 : RUN rm /etc/nginx/conf.d/default.conf
 ---> Using cache
Step 11/12 : COPY nginx/static.conf /etc/nginx/conf.d
 ---> Using cache
Step 12/12 : COPY --from=builder /app/dist/app .
Successfully built a44dd7c217c3
Successfully tagged app:latest

real 0m46.497s
user 0m0.000s
sys 0m0.000s

46 שניות במקום 3 דקות - הרבה יותר טוב! הסדר הנכון של השכבות חשוב: ראשית נעתיק את מה שלא משתנה, אחר כך את מה שמשתנה לעיתים רחוקות, ולבסוף את מה שמשתנה לעיתים קרובות.

לאחר מכן, כמה מילים על הרכבת תמונות במערכות CI/CD.

שימוש בתמונות קודמות למטמון

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

בואו ניקח דוגמה לבניית האפליקציה שלנו ב-GitHub Actions. אנו משתמשים בתצורה זו

on:
  push:
    branches:
      - master

name: Test docker build

jobs:
  deploy:
    name: Build
    runs-on: ubuntu-latest
    env:
      IMAGE_NAME: docker.pkg.github.com/${{ github.repository }}/app
      IMAGE_TAG: ${{ github.sha }}

    steps:
    - name: Checkout
      uses: actions/checkout@v2

    - name: Login to GitHub Packages
      env:
        TOKEN: ${{ secrets.GITHUB_TOKEN }}
      run: |
        docker login docker.pkg.github.com -u $GITHUB_ACTOR -p $TOKEN

    - name: Build
      run: |
        docker build 
          -t $IMAGE_NAME:$IMAGE_TAG 
          -t $IMAGE_NAME:latest 
          .

    - name: Push image to GitHub Packages
      run: |
        docker push $IMAGE_NAME:latest
        docker push $IMAGE_NAME:$IMAGE_TAG

    - name: Logout
      run: |
        docker logout docker.pkg.github.com

התמונה מורכבת ונדחפת לחבילות GitHub תוך שתי דקות ו-20 שניות:

עכשיו בואו נשנה את המבנה כך שישמש מטמון על סמך תמונות שנבנו בעבר:

on:
  push:
    branches:
      - master

name: Test docker build

jobs:
  deploy:
    name: Build
    runs-on: ubuntu-latest
    env:
      IMAGE_NAME: docker.pkg.github.com/${{ github.repository }}/app
      IMAGE_TAG: ${{ github.sha }}

    steps:
    - name: Checkout
      uses: actions/checkout@v2

    - name: Login to GitHub Packages
      env:
        TOKEN: ${{ secrets.GITHUB_TOKEN }}
      run: |
        docker login docker.pkg.github.com -u $GITHUB_ACTOR -p $TOKEN

    - name: Pull latest images
      run: |
        docker pull $IMAGE_NAME:latest || true
        docker pull $IMAGE_NAME-builder-stage:latest || true

    - name: Images list
      run: |
        docker images

    - name: Build
      run: |
        docker build 
          --target builder 
          --cache-from $IMAGE_NAME-builder-stage:latest 
          -t $IMAGE_NAME-builder-stage 
          .
        docker build 
          --cache-from $IMAGE_NAME-builder-stage:latest 
          --cache-from $IMAGE_NAME:latest 
          -t $IMAGE_NAME:$IMAGE_TAG 
          -t $IMAGE_NAME:latest 
          .

    - name: Push image to GitHub Packages
      run: |
        docker push $IMAGE_NAME-builder-stage:latest
        docker push $IMAGE_NAME:latest
        docker push $IMAGE_NAME:$IMAGE_TAG

    - name: Logout
      run: |
        docker logout docker.pkg.github.com

ראשית עלינו לספר לך מדוע מופעלות שתי פקודות build. העובדה היא שבהרכבה רב-שלבית התמונה שתתקבל תהיה קבוצה של שכבות מהשלב האחרון. במקרה זה, שכבות משכבות קודמות לא ייכללו בתמונה. לכן, בעת שימוש בתמונה הסופית מבנייה קודמת, Docker לא יוכל למצוא שכבות מוכנות לבניית התמונה עם nodejs (שלב הבונה). על מנת לפתור בעיה זו נוצרת תמונת ביניים $IMAGE_NAME-builder-stage והוא נדחף לחבילות GitHub כך שניתן יהיה להשתמש בו בבנייה הבאה כמקור מטמון.

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

הדמיה מוקדמת

דרך נוספת לפתור את הבעיה של מטמון Docker נקי היא להעביר חלק מהשכבות לתוך Dockerfile אחר, לבנות אותו בנפרד, לדחוף אותו ל-Container Registry ולהשתמש בו כהורה.

אנו יוצרים תמונת nodejs משלנו כדי לבנות יישום Angular. צור Dockerfile.node בפרויקט

FROM node:12.16.2-alpine3.11
RUN apk --no-cache --update --virtual build-dependencies add 
    python 
    make 
    g++

אנו אוספים ודוחפים תמונה ציבורית ב-Docker Hub:

docker build -t exsmund/node-for-angular -f Dockerfile.node .
docker push exsmund/node-for-angular:latest

כעת ב- Dockerfile הראשי שלנו אנו משתמשים בתמונה המוגמרת:

FROM exsmund/node-for-angular:latest as builder
...

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

בדקנו מספר שיטות להאצת בניית תמונות docker. אם אתה רוצה שהפריסה תעבור במהירות, נסה להשתמש בזה בפרויקט שלך:

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

אני מקווה שהדוגמה תבהיר יותר איך Docker עובד, ותוכל להגדיר בצורה אופטימלית את הפריסה שלך. על מנת לשחק עם הדוגמאות מהמאמר, נוצר מאגר https://github.com/devopsprodigy/test-docker-build.

מקור: www.habr.com