🥇គន្លឹះខ្លះៗអំពីរបៀបបង្កើនល្បឿនបង្កើតរូបភាព Docker ។ ឧទាហរណ៍រហូតដល់ 30 វិនាទី

មុនពេលដែលលក្ខណៈពិសេសមួយចូលដំណើរការផលិត ក្នុងថ្ងៃនៃក្រុមអ្នកសំដែងដ៏ស្មុគស្មាញ និង CI/CD មានផ្លូវដ៏វែងឆ្ងាយដើម្បីបន្តពីការប្តេជ្ញាចិត្តទៅកាន់ការធ្វើតេស្ត និងការចែកចាយ។ ពីមុនអ្នកអាចផ្ទុកឯកសារថ្មីតាមរយៈ FTP (គ្មាននរណាម្នាក់ធ្វើវាទៀតទេមែនទេ?) ហើយដំណើរការ "ការដាក់ពង្រាយ" ចំណាយពេលប៉ុន្មានវិនាទី។ ឥឡូវនេះ អ្នកត្រូវបង្កើតសំណើបញ្ចូលគ្នា ហើយរង់ចាំរយៈពេលយូរសម្រាប់មុខងារនេះអាចឈានដល់អ្នកប្រើ។

ផ្នែកមួយនៃផ្លូវនេះគឺការកសាងរូបភាព Docker ។ ពេលខ្លះការជួបជុំមានរយៈពេលមួយនាទី ជួនកាលរាប់សិបនាទី ដែលពិបាកហៅថាធម្មតាណាស់។ នៅក្នុងអត្ថបទនេះ យើងនឹងលើកយកកម្មវិធីសាមញ្ញមួយ ដែលយើងនឹងដាក់ក្នុងរូបភាពមួយ អនុវត្តវិធីសាស្រ្តជាច្រើនដើម្បីបង្កើនល្បឿននៃការបង្កើត និងមើលការខុសប្លែកគ្នានៃរបៀបដែលវិធីសាស្រ្តទាំងនេះដំណើរការ។

យើងមានបទពិសោធន៍ល្អក្នុងការបង្កើត និងគាំទ្រគេហទំព័រប្រព័ន្ធផ្សព្វផ្សាយ៖ Tass, កណ្តឹង, "កាសែតថ្មី", សាធារណរដ្ឋ… មិនយូរប៉ុន្មាន យើងបានពង្រីកផលប័ត្ររបស់យើងដោយការចេញផ្សាយគេហទំព័រផលិតផល ការរំលឹក. ហើយខណៈពេលដែលមុខងារថ្មីត្រូវបានបន្ថែមយ៉ាងឆាប់រហ័ស ហើយកំហុសចាស់ត្រូវបានជួសជុល ការដាក់ពង្រាយយឺតបានក្លាយជាបញ្ហាធំ។

យើងដាក់ពង្រាយទៅ GitLab ។ យើងប្រមូលរូបភាព រុញពួកវាទៅ GitLab Registry ហើយរមៀលវាចេញទៅផលិតកម្ម។ រឿងវែងបំផុតក្នុងបញ្ជីនេះគឺការផ្គុំរូបភាព។ ឧទាហរណ៍៖ ដោយគ្មានការបង្កើនប្រសិទ្ធភាព ការបង្កើតផ្នែកខាងក្រោយនីមួយៗបានចំណាយពេល 14 នាទី។

នៅទីបញ្ចប់ វាច្បាស់ថាយើងមិនអាចរស់នៅបែបនេះទៀតទេ ហើយយើងអង្គុយចុះដើម្បីរកមូលហេតុដែលរូបភាពទាំងនោះចំណាយពេលយូរក្នុងការប្រមូល។ ជាលទ្ធផល យើងបានកាត់បន្ថយពេលវេលាដំឡើងមកត្រឹម 30 វិនាទី!

សម្រាប់អត្ថបទនេះ ដើម្បីកុំឱ្យជាប់ទាក់ទងនឹងបរិស្ថានរបស់កម្មវិធីរំលឹក សូមក្រឡេកមើលឧទាហរណ៍នៃការដំឡើងកម្មវិធី 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 នីមួយៗអាចផ្ទុកទិន្នន័យបាន។ ប្រសិនបើគ្មានអ្វីបានផ្លាស់ប្តូរចាប់តាំងពីការស្ថាបនាចុងក្រោយ នោះជំនួសឱ្យការប្រតិបត្តិពាក្យបញ្ជានោះ docker នឹងយកស្រទាប់ដែលត្រៀមរួចជាស្រេច។ ដោយសារការកើនឡើងដ៏សំខាន់នៃល្បឿនសាងសង់នឹងកើតឡើងដោយសារការប្រើប្រាស់ឃ្លាំងសម្ងាត់ នៅពេលវាស់ល្បឿនសាងសង់ យើងនឹងយកចិត្តទុកដាក់ជាពិសេសចំពោះការបង្កើតរូបភាពជាមួយនឹងឃ្លាំងសម្ងាត់ដែលត្រៀមរួចជាស្រេច។ ដូច្នេះជាជំហាន ៗ ៖

យើងលុបរូបភាពក្នុងមូលដ្ឋាន ដើម្បីកុំឱ្យដំណើរការពីមុនប៉ះពាល់ដល់ការសាកល្បង។
docker rmi $(docker images -q)
យើងបើកដំណើរការសាងសង់ជាលើកដំបូង។
time docker build -t app .
យើងផ្លាស់ប្តូរឯកសារ src/index.html - យើងធ្វើត្រាប់តាមការងាររបស់អ្នកសរសេរកម្មវិធី។
យើងដំណើរការការសាងសង់ជាលើកទីពីរ។
time docker build -t app .

ប្រសិនបើបរិស្ថានសម្រាប់រូបភាពសាងសង់ត្រូវបានកំណត់ត្រឹមត្រូវ (បន្ថែមលើវាខាងក្រោម) នោះនៅពេលដែលការស្ថាបនាចាប់ផ្តើម Docker នឹងមានឃ្លាំងសម្ងាត់ជាច្រើននៅលើយន្តហោះរួចហើយ។ ភារកិច្ចរបស់យើងគឺរៀនពីរបៀបប្រើឃ្លាំងសម្ងាត់ដើម្បីឱ្យការស្ថាបនាដំណើរការលឿនតាមដែលអាចធ្វើទៅបាន។ ដោយសារយើងសន្មត់ថាការដំណើរការការស្ថាបនាដោយគ្មានឃ្លាំងសម្ងាត់កើតឡើងតែម្តងប៉ុណ្ណោះ—ជាលើកទីមួយ—ដូច្នេះហើយ យើងអាចមិនអើពើថាតើពេលដំបូងនោះយឺតប៉ុណ្ណា។ នៅក្នុងការធ្វើតេស្ត ការដំណើរការទីពីរនៃការសាងសង់មានសារៈសំខាន់សម្រាប់យើង នៅពេលដែលឃ្លាំងសម្ងាត់ត្រូវបានកំដៅឡើង ហើយយើងត្រៀមខ្លួនរួចរាល់ដើម្បីដុតនំរបស់យើង។ ទោះជាយ៉ាងណាក៏ដោយ គន្លឹះខ្លះក៏នឹងប៉ះពាល់ដល់ការសាងសង់ដំបូងផងដែរ។

ចូរដាក់ Dockerfile ដែលបានពិពណ៌នាខាងលើនៅក្នុងថតគម្រោង ហើយចាប់ផ្តើមការស្ថាបនា។ បញ្ជីទាំងអស់ត្រូវបានបង្រួម ដើម្បីងាយស្រួលអាន។

$ 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. បរិបទសាងសង់ត្រូវបានបញ្ជាក់ជាអាគុយម៉ង់ចុងក្រោយចំពោះពាក្យបញ្ជាសាងសង់។ ក្នុងករណីរបស់យើង នេះគឺជាថតបច្ចុប្បន្ន - ".", - ហើយ Docker អូសអ្វីគ្រប់យ៉ាងដែលយើងមាននៅក្នុងថតនេះ។ 409 MB គឺច្រើន៖ តោះគិតពីរបៀបជួសជុលវា។

ការកាត់បន្ថយបរិបទ

ដើម្បីកាត់បន្ថយបរិបទ មានជម្រើសពីរ។ ឬដាក់ឯកសារទាំងអស់ដែលត្រូវការសម្រាប់ការជួបប្រជុំគ្នានៅក្នុងថតដាច់ដោយឡែកមួយ ហើយចង្អុលបរិបទ docker ទៅកាន់ថតនេះ។ នេះប្រហែលជាមិនតែងតែងាយស្រួលទេ ដូច្នេះវាអាចបញ្ជាក់ករណីលើកលែង៖ អ្វីដែលមិនគួរអូសចូលទៅក្នុងបរិបទ។ ដើម្បីធ្វើដូចនេះដាក់ឯកសារ .dockerignore នៅក្នុងគម្រោង ហើយចង្អុលបង្ហាញអ្វីដែលមិនត្រូវការសម្រាប់ការសាងសង់៖

.git
/node_modules

ហើយដំណើរការសាងសង់ម្តងទៀត៖

$ 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 ។ ក្នុងករណីរបស់យើង យើងកំពុងប្រើរូបភាពដែលមានមូលដ្ឋានលើ Ubuntu ដែលបានដំឡើង nodejs រួចហើយ។ ហើយវាមានទម្ងន់ ...

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

... ស្ទើរតែមួយជីហ្គាបៃ។ អ្នកអាចកាត់បន្ថយកម្រិតសំឡេងយ៉ាងខ្លាំងដោយប្រើរូបភាពដែលមានមូលដ្ឋានលើ Alpine Linux ។ Alpine គឺជាលីនុចតូចណាស់។ រូបភាព docker សម្រាប់ nodejs ផ្អែកលើអាល់ផែនមានទម្ងន់ត្រឹមតែ 88.5 MB ប៉ុណ្ណោះ។ ដូច្នេះសូមជំនួសរូបភាពដ៏រស់រវើករបស់យើងនៅក្នុងផ្ទះ៖

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 ដាក់ folder ចូល 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 GB ដល់ 36 MB កាត់បន្ថយពេលវេលាយ៉ាងសំខាន់ក្នុងការបញ្ជូនកម្មវិធីរបស់អ្នកទៅផលិតកម្ម។ ប៉ុន្តែសូមត្រលប់ទៅពេលវេលានៃការជួបប្រជុំគ្នា។

$ 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.338s ។ ហេតុអ្វីបានដំឡើងភាពអាស្រ័យឡើងវិញរាល់ពេល ប្រសិនបើពួកគេផ្លាស់ប្តូរកម្រណាស់? ចូរយើងស្វែងយល់ថាហេតុអ្វីបានជាពួកគេមិនត្រូវបានគេដាក់ក្នុងឃ្លាំងសម្ងាត់។ ចំនុចនោះគឺថា Docker នឹងពិនិត្យស្រទាប់ដោយស្រទាប់ ដើម្បីមើលថាតើពាក្យបញ្ជា និងឯកសារដែលភ្ជាប់ជាមួយវាបានផ្លាស់ប្តូរឬអត់។ នៅជំហានទី XNUMX យើងចម្លងឯកសារទាំងអស់នៃគម្រោងរបស់យើង ហើយក្នុងចំណោមពួកគេ ពិតណាស់មានការផ្លាស់ប្តូរ ដូច្នេះ 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 មួយផ្សេងទៀត បង្កើតវាដាច់ដោយឡែក រុញវាទៅក្នុងកុងតឺន័រចុះបញ្ជី ហើយប្រើវាជាមេ។

យើងបង្កើតរូបភាព 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

គន្លឹះខ្លះៗអំពីរបៀបបង្កើនល្បឿនបង្កើតរូបភាព Docker ។ ឧទាហរណ៍រហូតដល់ 30 វិនាទី