🥇Docker රූප ගොඩනැගීම වේගවත් කරන ආකාරය පිළිබඳ උපදෙස් කිහිපයක්. උදාහරණයක් ලෙස, තත්පර 30 දක්වා

විශේෂාංගයක් නිෂ්පාදනයට පැමිණීමට පෙර, සංකීර්ණ වාද්‍ය වෘන්දයේ සහ CI/CD හි මේ දිනවල, කැපවීමෙන් පරීක්ෂණ සහ බෙදා හැරීම දක්වා යාමට බොහෝ දුරක් ඇත. මීට පෙර, ඔබට FTP හරහා නව ගොනු උඩුගත කළ හැකිය (කිසිවෙකු තවදුරටත් එසේ කරන්නේ නැත, හරිද?), සහ "යෙදීම" ක්රියාවලිය තත්පර කිහිපයක් ගත විය. දැන් ඔබට ඒකාබද්ධ කිරීමේ ඉල්ලීමක් සෑදිය යුතු අතර විශේෂාංගය පරිශීලකයින් වෙත ළඟා වීමට දිගු කාලයක් රැඳී සිටින්න.

මෙම මාර්ගයේ කොටසක් ඩොකර් රූපයක් ගොඩනැගීමයි. සමහර විට එකලස් කිරීම මිනිත්තු කිහිපයක්, සමහර විට මිනිත්තු දස ගණනක්, එය සාමාන්‍ය යැයි කිව නොහැක. මෙම ලිපියෙන්, අපි සරල යෙදුමක් ගනිමු, අපි රූපයකට ඇසුරුම් කර, ගොඩනැගීම වේගවත් කිරීමට ක්‍රම කිහිපයක් යොදන්න, සහ මෙම ක්‍රම ක්‍රියාත්මක වන ආකාරය පිළිබඳ සූක්ෂ්ම කරුණු දෙස බලමු.

මාධ්‍ය වෙබ් අඩවි නිර්මාණය කිරීම සහ සහාය දීම සම්බන්ධයෙන් අපට හොඳ පළපුරුද්දක් ඇත: TASS, බෙල්, "නව පුවත්පත", ජනරජය… බොහෝ කලකට පෙර අපි නිෂ්පාදන වෙබ් අඩවියක් නිකුත් කිරීමෙන් අපගේ කළඹ පුළුල් කළෙමු මතක්. නව විශේෂාංග ඉක්මනින් එකතු කර පැරණි දෝෂ නිවැරදි කරන අතර, මන්දගාමී යෙදවීම විශාල ගැටළුවක් විය.

අපි GitLab වෙත යොදවන්නෙමු. අපි පින්තූර එකතු කර, GitLab රෙජිස්ට්රි වෙත තල්ලු කර නිෂ්පාදනයට පෙරළන්නෙමු. මෙම ලැයිස්තුවේ දිගම දෙය වන්නේ පින්තූර එකලස් කිරීමයි. උදාහරණයක් ලෙස: ප්‍රශස්තකරණයකින් තොරව, එක් එක් පසුබිම් ගොඩනැගීමට මිනිත්තු 14ක් ගත විය.

අවසානයේදී, අපට තවදුරටත් මෙසේ ජීවත් විය නොහැකි බව පැහැදිලි වූ අතර, පින්තූර එකතු කිරීමට මෙතරම් කාලයක් ගත වන්නේ මන්දැයි සොයා බැලීමට අපි වාඩි වී සිටියෙමු. එහි ප්රතිඵලයක් වශයෙන්, එකලස් කිරීමේ කාලය තත්පර 30 දක්වා අඩු කිරීමට අපට හැකි විය!

මෙම ලිපිය සඳහා, සිහිකැඳවීමේ පරිසරයට සම්බන්ධ නොවීම සඳහා, හිස් කෝණික යෙදුමක් එකලස් කිරීමේ උදාහරණයක් බලමු. එබැවින්, අපි අපගේ යෙදුම නිර්මාණය කරමු:

ng n app

එයට PWA එකතු කරන්න (අපි ප්‍රගතිශීලී):

ng add @angular/pwa --project app

npm පැකේජ මිලියනයක් බාගත වෙමින් පවතින අතරතුර, අපි ඩොකර් රූපය ක්‍රියා කරන්නේ කෙසේදැයි සොයා බලමු. Docker මඟින් යෙදුම් ඇසුරුම් කර ඒවා බහාලුමක් ලෙස හඳුන්වන හුදකලා පරිසරයක ධාවනය කිරීමේ හැකියාව සපයයි. හුදකලා කිරීමට ස්තූතියි, ඔබට එක් සේවාදායකයක් මත එකවර බහාලුම් රාශියක් ධාවනය කළ හැකිය. බහාලුම් අථත්‍ය යන්ත්‍රවලට වඩා සැහැල්ලු ය, මන්ද ඒවා පද්ධති කර්නලය මත කෙලින්ම ක්‍රියාත්මක වේ. අපගේ යෙදුම සමඟ කන්ටේනරයක් ධාවනය කිරීමට, අපි පළමුව අපගේ යෙදුම ක්‍රියාත්මක වීමට අවශ්‍ය සියල්ල ඇසුරුම් කරන රූපයක් නිර්මාණය කළ යුතුය. අත්යවශ්යයෙන්ම, රූපයක් යනු ගොනු පද්ධතියේ පිටපතකි. උදාහරණයක් ලෙස, Dockerfile ගන්න:

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

Dockerfile යනු උපදෙස් මාලාවකි; ඒ සෑම එකක්ම කිරීමෙන්, ඩොකර් විසින් ගොනු පද්ධතියේ වෙනස්කම් සුරකින අතර පෙර ඒවා මත ඒවා ආවරණය කරයි. සෑම කණ්ඩායමක්ම තමන්ගේම ස්ථරයක් නිර්මාණය කරයි. සහ නිමි රූපය ස්ථර එකට ඒකාබද්ධ වේ.

දැනගත යුතු වැදගත් දේ: එක් එක් ඩොකර් ස්ථරයට හැඹිලිගත හැක. අවසාන ගොඩනැගීමේ සිට කිසිවක් වෙනස් වී නොමැති නම්, විධානය ක්‍රියාත්මක කිරීම වෙනුවට, ඩොකර් සූදානම් කළ තට්ටුවක් ගනු ඇත. ගොඩනැගීමේ වේගයේ ප්‍රධාන වැඩිවීම හැඹිලිය භාවිතා කිරීම නිසා වන බැවින්, ගොඩනැගීමේ වේගය මැනීමේදී අපි විශේෂයෙන් සූදානම් කළ හැඹිලියක් සහිත රූපයක් තැනීම කෙරෙහි අවධානය යොමු කරමු. ඉතින්, පියවරෙන් පියවර:

පෙර ධාවනය පරීක්ෂණයට බලපාන්නේ නැති නිසා අපි පින්තූර දේශීයව මකා දමමු.
docker rmi $(docker images -q)
අපි පළමු වරට ගොඩනැගීම ආරම්භ කරමු.
time docker build -t app .
අපි src/index.html ගොනුව වෙනස් කරමු - අපි ක්‍රමලේඛකයෙකුගේ කාර්යය අනුකරණය කරමු.
අපි ගොඩනැගීම දෙවන වරටත් ක්රියාත්මක කරන්නෙමු.
time docker build -t app .

රූප තැනීම සඳහා පරිසරය නිවැරදිව වින්‍යාස කර ඇත්නම් (පහත වැඩි විස්තර), එවිට ගොඩනැගීම ආරම්භ වන විට, ඩොකර් සතුව දැනටමත් හැඹිලි පොකුරක් ඇත. අපගේ කාර්යය වන්නේ හැඹිලිය භාවිතා කරන ආකාරය ඉගෙන ගැනීමයි, එවිට ගොඩනැගීම හැකි ඉක්මනින් සිදු වේ. හැඹිලියක් නොමැතිව ගොඩනැගීමක් ක්‍රියාත්මක වන්නේ එක් වරක් පමණක් යැයි අපි උපකල්පනය කරන බැවින් - පළමු වරට - එම පළමු අවස්ථාව කෙතරම් මන්දගාමී දැයි අපට නොසලකා හැරිය හැක. පරීක්ෂණ වලදී, හැඹිලි දැනටමත් උණුසුම් වී ඇති අතර, අපි අපේ කේක් පිළිස්සීමට සූදානම් වන විට, ගොඩනැගීමේ දෙවන ධාවනය අපට වැදගත් වේ. කෙසේ වෙතත්, සමහර ඉඟි පළමු ගොඩනැගීමට ද බලපානු ඇත.

ඉහත විස්තර කර ඇති Dockerfile එක Project folder එකට දමා ගොඩනැගීම ආරම්භ කරමු. සියලුම ලැයිස්තුගත කිරීම් කියවීමේ පහසුව සඳහා ඝනීභවනය කර ඇත.

$ 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

ගොඩනැගීමට පෙර, ඩොකර් වත්මන් සන්දර්භය තුළ ඇති සියලුම ගොනු ගෙන එහි ඩීමන් වෙත යවයි Sending build context to Docker daemon 409MB. ගොඩනැගීමේ සන්දර්භය ගොඩනැගීමේ විධානයේ අවසාන තර්කය ලෙස දක්වා ඇත. අපගේ නඩුවේදී, මෙය වත්මන් නාමාවලියයි - ".", - සහ ඩොකර් මෙම ෆෝල්ඩරයේ ඇති සියල්ල ඇදගෙන යයි. 409 MB ගොඩක්: අපි එය නිවැරදි කරන්නේ කෙසේදැයි සිතා බලමු.

සන්දර්භය අඩු කිරීම

සන්දර්භය අඩු කිරීම සඳහා, විකල්ප දෙකක් තිබේ. නැතහොත් එකලස් කිරීමට අවශ්‍ය සියලුම ගොනු වෙනම ෆෝල්ඩරයකට දමා ඩොකර් සන්දර්භය මෙම ෆෝල්ඩරයට යොමු කරන්න. මෙය සැමවිටම පහසු නොවිය හැක, එබැවින් ව්යතිරේක සඳහන් කළ හැකිය: සන්දර්භය තුළට ඇදගෙන නොයා යුතු දේ. මෙය සිදු කිරීම සඳහා, .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 හි. අපගේ නඩුවේදී, අපි භාවිතා කරන්නේ දැනටමත් nodejs ස්ථාපනය කර ඇති Ubuntu මත පදනම් වූ රූපයකි. ඒ වගේම බරයි...

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

... ගිගාබයිට් එකකට ආසන්නයි. Alpine Linux මත පදනම් වූ රූපයක් භාවිතා කිරීමෙන් ඔබට ශබ්දය සැලකිය යුතු ලෙස අඩු කළ හැකිය. ඇල්පයින් යනු ඉතා කුඩා ලිනක්ස් වර්ගයකි. ඇල්පයින් මත පදනම් වූ 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

අපිට Application එක හදන්න අවශ්‍ය දේවල් ටිකක් Install කරන්න උනා. ඔව්, Python ¯(°_o)/¯ නොමැතිව Angular ගොඩ නැගෙන්නේ නැත

නමුත් රූපයේ ප්‍රමාණය 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. මේකෙදි කොහොම හරි ෆයිල් ටික එලියට දෙන්න ඕන. ඔබට nodejs මත HTTP සේවාදායකයක් ධාවනය කළ හැක. නමුත් අපි එය පහසු කරන්නෙමු. "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 වරාය nginx ධාවනය වන බහාලුම් තුළ ඇති 80 වරාය වෙත යොමු කළෙමු. බ්‍රවුසරයේ විවෘත කරන්න 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.338 ක් තරම්. පරායත්තතා ඉතා කලාතුරකින් වෙනස් වුවහොත් ඒවා නැවත ස්ථාපනය කරන්නේ ඇයි? ඒවා හැඹිලිගත නොකළේ මන්දැයි සොයා බලමු. කාරණය වන්නේ විධානය සහ ඒ හා සම්බන්ධ ලිපිගොනු වෙනස් වී ඇත්දැයි බැලීමට ඩොකර් ස්ථරයෙන් ස්ථරය පරීක්ෂා කරයි. සිව්වන පියවරේදී, අපි අපගේ ව්‍යාපෘතියේ සියලුම ලිපිගොනු පිටපත් කරන අතර, ඒවා අතර, ඇත්ත වශයෙන්ම, වෙනස්කම් ඇත, එබැවින් ඩොකර් මෙම ස්තරය හැඹිලියෙන් පමණක් නොගනී, නමුත් පසුව ඇති සියලුම ඒවා ද! අපි 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 සහ pack-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 විසඳුමක් භාවිතා කරන්නේ නම්, දේශීය ඩොකර් හැඹිලිය පිරිසිදු හා නැවුම් විය හැකිය. ඩොකර්ට බේක් කරන ලද ස්ථර ලබා ගැනීමට ස්ථානයක් ලබා දීම සඳහා, ඔහුට කලින් ගොඩනඟන ලද රූපය ලබා දෙන්න.

GitHub ක්‍රියා වල අපගේ යෙදුම ගොඩනැගීමේ උදාහරණයක් ගනිමු. අපි මේ config එක පාවිච්චි කරනවා

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

රූපය එකලස් කර විනාඩි දෙකයි තත්පර 20 කින් GitHub පැකේජ වෙත තල්ලු කරනු ලැබේ:

දැන් අපි ගොඩනැගීම වෙනස් කරමු එවිට පෙර සාදන ලද පින්තූර මත පදනම්ව හැඹිලියක් භාවිතා වේ:

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. කාරණය වන්නේ බහු-අදියර එකලස් කිරීමේදී ලැබෙන රූපය අවසාන අදියරේ සිට ස්ථර කට්ටලයක් වනු ඇත. මෙම අවස්ථාවේදී, පෙර ස්ථර වලින් ස්ථර රූපයට ඇතුළත් නොවේ. එබැවින්, පෙර ගොඩනැගීමේ අවසාන රූපය භාවිතා කරන විට, nodejs (builder stage) සමඟ රූපය ගොඩනැගීමට සූදානම් ස්ථර සොයා ගැනීමට Docker හට නොහැකි වනු ඇත. මෙම ගැටළුව විසඳීම සඳහා අතරමැදි රූපයක් නිර්මාණය වේ $IMAGE_NAME-builder-stage සහ GitHub පැකේජ වෙත තල්ලු කරනු ලබන අතර එමඟින් එය පසුකාලීන ගොඩනැගීමේදී හැඹිලි ප්‍රභවයක් ලෙස භාවිතා කළ හැක.

සම්පූර්ණ එකලස් කිරීමේ කාලය විනාඩි එකහමාරකට අඩු විය. මිනිත්තු භාගයක් පෙර පින්තූර ඉහළට ඇද දමයි.

පූර්ව නිරූපණය

Clean Docker cache එකක ගැටලුව විසඳීමට තවත් ක්‍රමයක් නම්, ලේයර් කිහිපයක් වෙනත් Dockerfile එකකට ගෙන ගොස්, එය වෙනම ගොඩනඟා, Container Registry වෙත තල්ලු කර එය දෙමාපියන් ලෙස භාවිතා කිරීමයි.

අපි කෝණික යෙදුමක් තැනීම සඳහා අපගේම nodejs රූපයක් නිර්මාණය කරමු. ව්‍යාපෘතියේ 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
...

අපගේ උදාහරණයේ දී, ගොඩනැගීමේ කාලය අඩු වී නැත, නමුත් ඔබට බොහෝ ව්‍යාපෘති තිබේ නම් සහ ඒ සෑම එකක් තුළම එකම පරායත්තතා ස්ථාපනය කළ යුතු නම්, පෙර-සාදන ලද පින්තූර ප්‍රයෝජනවත් විය හැකිය.

ඩොකර් රූප ගොඩනැගීම වේගවත් කිරීම සඳහා අපි ක්‍රම කිහිපයක් දෙස බැලුවෙමු. ඔබට යෙදවීම ඉක්මනින් සිදු වීමට අවශ්‍ය නම්, ඔබේ ව්‍යාපෘතිය තුළ මෙය භාවිතා කිරීමට උත්සාහ කරන්න:

සන්දර්භය අඩු කිරීම;
කුඩා මාපිය රූප භාවිතය;
බහු අදියර එකලස් කිරීම;
හැඹිලිය කාර්යක්ෂමව භාවිතා කිරීම සඳහා Dockerfile හි උපදෙස් අනුපිළිවෙල වෙනස් කිරීම;
CI/CD පද්ධතිවල හැඹිලියක් සැකසීම;
රූපවල මූලික නිර්මාණය.

Docker ක්‍රියා කරන ආකාරය උදාහරණයෙන් පැහැදිලි වනු ඇතැයි මම බලාපොරොත්තු වෙමි, සහ ඔබට ඔබගේ යෙදවීම ප්‍රශස්ත ලෙස වින්‍යාස කිරීමට හැකි වනු ඇත. ලිපියේ උදාහරණ සමඟ සෙල්ලම් කිරීම සඳහා, ගබඩාවක් නිර්මාණය කර ඇත https://github.com/devopsprodigy/test-docker-build.

මූලාශ්රය: www.habr.com

ඩොකර් රූප ගොඩනැගීම වේගවත් කරන්නේ කෙසේද යන්න පිළිබඳ උපදෙස් කිහිපයක්. උදාහරණයක් ලෙස, තත්පර 30 දක්වා

සන්දර්භය අඩු කිරීම

අපි ඇල්පයින් භාවිතා කරමු

බහු අදියර එකලස් කිරීම

ස්ථර අනුපිළිවෙල වෙනස් කිරීම

හැඹිලිය සඳහා පෙර පින්තූර භාවිතා කිරීම

පූර්ව නිරූපණය

අදහස් එක් කරන්න

ඩොකර් රූප ගොඩනැගීම වේගවත් කරන්නේ කෙසේද යන්න පිළිබඳ උපදෙස් කිහිපයක්. උදාහරණයක් ලෙස, තත්පර 30 දක්වා

සන්දර්භය අඩු කිරීම

අපි ඇල්පයින් භාවිතා කරමු

බහු අදියර එකලස් කිරීම

ස්ථර අනුපිළිවෙල වෙනස් කිරීම

හැඹිලිය සඳහා පෙර පින්තූර භාවිතා කිරීම

පූර්ව නිරූපණය

අදහස් එක් කරන්න ඊ-මේල් මගින් පිලිතුරු දෙන්න අවලංගු

අදහස් එක් කරන්න