Aliquot tips in quam accelerare imagines Docker aedificat. Exempli gratia, usque ad XXX seconds

Priusquam pluma productionem ingrediatur, his diebus orchestratores complexi et CI/CD, longa via est abeundi a committo ad probationes et traditiones. Antea, tabellas novas per FTP fasciculos imponere potuisti (nemo id amplius, ius?), et processum "instruere" secundas cepit. Nunc opus est rogationem merge creare et diu expectare pluma ut utentes attingas.

Huius viae pars imaginem aedificat Docker. Coetus interdum minutas, interdum decem minutas durat, quae vix normales dici possunt. In hoc articulo, simplicem applicationem adhibebimus quam imaginem in sarcinam dabimus, plures methodos adhibebimus ad aedificandum accelerandum, et inspiciemus quot methodi methodi haec operantur.

Experientiam bonam habemus in instrumentis creandis et sustentandis in websites: Tass, De Bell, "New Newspaper", publica... Non ita pridem nostrum librarium dilatavimus solvendo producti website admonitio. Dum nova lineamenta celeriter addita sunt et cimices veteres fixi sunt, instruere tardus ad multam quaestionem factus est.

explicamus ad GitLab. Imagines colligimus, eas ad GitLab Subcriptio impellimus et eas ad productionem devolvimus. Longissimum est in hoc indice imagines congregare. Exempli gratia: sine optimizatione, singula backend constructum ceperunt XIIII minuta.

In fine, patuit quod non potuimus amplius vivere, et sedimus ad figurandum cur imagines tamdiu colligerent. Quam ob rem nos conventus tempus ad 30 seconds reducere potuimus!

Hoc articulum, ne in ambitu Remonitionis ligandum, exemplum inspiciamus applicationis vacuae angularis congregandae. Itaque applicatione nostram faciamus:

ng n app

Adde PWA ei (gradivi sumus);

ng add @angular/pwa --project app

Dum myriades npm fasciculi inducuntur, exprimamus quomodo opera imago agit. Docker facultatem ad sarcinas applicationes praebet et eas in ambitu solitario vocato continens. Propter solitudinem, multa vasa simul in uno servo currere potes. Vasa machinis virtualis multo leviora sunt quia directe in systematis nuclei currunt. Ad vas currendum cum applicatione nostra, primum opus est imaginem creare in qua sarcinam dabimus omnia quae ad usum nostrum ad currendum necessaria sunt. Essentialiter, imago est exemplar tabellae ratio. Exempli gratia: Dockerfile sumatur:

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

A Dockerfile instructionum copia est; Quodlibet eorum faciendo, Docker mutationes tabellariorum servabit et eas in prioribus operiet. Quisque eget orci accumsan ipsum. Et imago perfecta laminis simul componitur.

Quod scire interest: quisque stratum Docker cache potest. Si nihil mutatum est cum postremum aedificet, tum potius mandatum exequendi, capax tabulatum promptum accipiet. Cum celeritas principalis incrementi aedificandi usui cella erit, cum celeritatem aedificandi metientes operam dabimus nominatim ad imaginem aedificandam cum prompto cella. Sic pedetentim;

1. Imagines localiter delemus ut prior decurrit probationem non afficit.
   docker rmi $(docker images -q)
2. Lorem aedificare primum.
   time docker build -t app .
3. Mutamus tabellam src/index.html - opus programmarii imitamur.
4. Currimus, iterum aedificamus.
   time docker build -t app .

Si ambitus imaginum aedificiorum recte configuratur (more infra), tum cum incipit aedificare, Docker fasciculum in tabula iam habebit. Nostrum est discere quomodo uti cella ut quam celerrime aedificetur. Cum nos suppono quod sine cella currit aedificium solum semel accidit — primum ipsum — idcirco ignorare possumus quam tardus illud tempus sit. In probationibus, secundus cursus aedificationis magni momenti est nobis, cum cella iam calefacta sunt et placentam nostram coquendam parati sumus. Sed nonnulli etiam apicibus afficiunt primum constructum.

Ponamus Dockerfile supra descripto in folder incepto et aedificationis initium faciamus. Omnia listings pro lectionis facilitate condensata sunt.

$ 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

Mutamus contenta src/index.html et curramus secundo.

$ 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

Si imaginem habemus, curre mandatum docker images:

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

Priusquam aedificaretur, auctor omnes tabellas in contextu praesenti accipit et ad daemonem suum mittit Sending build context to Docker daemon 409MB. Contextus constructus specificatur sicut argumentum ultimum ad mandatum aedificandi. In nobis, haec est index currentis - “., — et Docker trahit omnia quae in hoc folder habemus. 409 MB multum est: cogitemus quomodo reficere possit.

Reducing contextu

Ad contextum redigendum duae sunt optiones. Aut omnia documenta necessaria pro contione pone in folder separato et in contextu huius folder monstrare. Id non semper convenit, ideo exceptiones specificare potest: quae in contextum trahi non debent. Ad hoc faciendum, tabella .dockerignore pone in incepto et indica quid ad aedificandum opus non sit;

.git
/node_modules

et currunt iterum aedificant;

$ 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 multo melior quam 409 MB. Etiam magnitudo imaginis redegit ab 1.74 ad 1.38 GB:

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

Amplius imaginem imaginis minuere conemur.

Utimur Alpini

Alio modo ad magnitudinem imaginis salvandam est parva imago parentis. Parentis imago est imago ex qua imago nostra praeparatur. Fundum iacuit per mandatum specificatur FROM in Dockerfile. In casu nostro, Ubuntu-substructio imagine utimur quae iam nodejs inauguratus est. Et gravat...

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

Prope ... gigabyte. Volumen signanter reducere potes utendo imagine in Alpina Linux. Alpina Linux perexigua est. Docker image for nodejs in alpinis tantum ponderat 88.5 MB. Vivam igitur imaginem in domibus restituamus;

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

Debemus instituere aliqua quae ad applicationem aedificandae necessaria sunt. Ita, angulari sine Pythone non aedificat (°_o)/¯

Sed magnitudo imaginis omissa est ad 150 MB:

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

Etiam longius eamus.

Multistage conventus

Non enim omne quod ad imaginem est, id quod in productione est, necessarium est.

$ 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

cum docker run app ls -lah nos vas secundum imaginem nostram launched app atque in eo imperium exercuit ls -lahpost quem continens opus suum peregit.

In productione solum opus est folder dist. Hoc in casu, tabellae aliquo modo foris tradendae sunt. Aliquam HTTP server in nodejs currere potes. Sed faciliorem dabimus. Conice verbum Russicum quod quattuor litterae "y" habet. Recte! Ynzhynyksy. Sumamus imaginem cum nginx, pone in eo folder dist et parva config;

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

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

Multi scaena aedificandi adiuvabit nos haec omnia. Dockerfile nostrum mutemus:

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 .

Nunc duas instructiones habemus FROM in Dockerfile, uterque alius gradus constructum currit. Vocavimus primum buildersed ab ultimo EX, ultima nostra parabitur imago. Ultimus gradus est artificium conventus nostri in priore gradu in ultima imagine cum nginx imitari. Magnitudo imaginis signanter decrevit;

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

Continentem cum imagine curramus et opera omnia fac:

docker run -p8080:80 app

-p8080:80 optione usi sumus, 8080 portum exercitum in machinam nostram ad portum 80 intra continentem transmisimus quo nginx currit. In aperto pasco http://localhost:8080/ et nostram applicationem videmus. Omnia laborat!

Reducendo magnitudinem imaginis ab 1.74 GB ad 36 MB signanter minuit tempus illud quod applicationem tuam ad productionem tradendam capit. Sed ad tempus conventus eamus.

$ 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

Mutato ordine laminis

Nostri primi tres gradus conditivo (monitus Using cache). In quarto gradu omnia documenta exscripta sunt et in quinto gradu dependentiae installantur RUN npm ci — quantum 47.338s. Cur clientelas restituo omni tempore, si rarissime mutantur? Sit figura quare non sunt conditivo. Punctum est quod Docker iacuit per tabulatum reprehendo videre si mandatum et lima consociata cum eo mutata sunt. In quarto gradu omnes tabulas propositi nostri describimus, inter quas, utique, mutationes sunt, ita Docker non solum hunc tabulatum non e cella, sed etiam omnes posteriores accipit! Dockerfile aliquas mutationes faciamus.

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 .

Primum, package.json et sarcina-lock.json exscripta sunt, deinde clientelae installantur, et solum postquam totum consilium exscriptus est. Igitur:

$ 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

XLVI seconds pro III minutis - multo melius! Rectus ordo laminis maximus est: primum imitamur quid non mutat, deinde quid raro mutat, postremo quid saepe mutat.

Deinceps pauca verba de systematibus convocandis in CI/CD.

Imagines per priorem pro cache

Si solutione Saas aliquali utimur pro aedificatione, tunc cella Docker loci munda et recens erit. Locum dare in nave tostas tostas recipere, ei priorem imaginem aedificatam dare.

Exemplum sumamus de applicatione nostra in actionibus GitHub aedificandi. Hoc config utimur

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

Simulacrum collectum est et coniectum ad sarcinas GitHub in duobus minutis et 20 secundis;

Nunc constructum mutemus ut cella in imaginibus constructis praecedentibus adhibetur;

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

Primum tibi dicere necesse est cur duo mandata deducantur build. Re vera in multistages comitiis imago resultans erit ex ultimis stadiis statuta stratorum. In hoc casu, strata a priori stratis in imagine non comprehenduntur. Cum igitur utens imaginem finalem ex priore aedificio, Docker paratos stratos invenire non poterit ut imaginem nodejs (scao aedificatoris) aedificare possit. Ad solvendam hanc quaestionem, imago media creata est $IMAGE_NAME-builder-stage et ad GitHub Packages impellitur ut in subsequenti aedificio uti fonte cella adhiberi possit.

Tota congregatio temporis ad unum et dimidium minuta redacta est. Dimidium minutum consumitur evellendo imagines priorum.

Preimaging

Alius modus solvendi problema de cache Docker mundi est movere quosdam e stratis in aliud Dockerfile, seorsim aedificare, in Subcriptio continentem impellere et uti parente.

Nodejs imaginem nostram creamus ad applicationem angularis aedificandae. Create Dockerfile.node in project

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

Colligimus et ventilamus imaginem publicam in Docker Hub:

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

Nunc in nostro principali Dockerfile imagini finitae utimur:

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

In exemplo nostro tempus aedificandi non decrevit, sed imagines praestructae utiles esse possunt si multa incepta habeant et easdem in unaquaque earum dependentias instituant.

Plures modos inspeximus ad accelerandam fabricam technicae imaginum. Si vis instruere ut cito ire, hoc in consilio tuo utere conare:

• contextu minuendo;
• imagines parvae parentis usu;
• multitudo, conventus;
• mutato mandatorum ordine in Dockerfile ad efficientem usum cache;
• cella in CI/CD systemata erigens;
• praevia imaginum creatione.

Exemplum, ut spero, clarius efficiet quomodo Docker opera, et optime instruere poteris. Ut exemplis e articulo ludere, repositio creata est https://github.com/devopsprodigy/test-docker-build.

Source: www.habr.com