E puer Tipps wéi Dir Docker Biller beschleunegt. Zum Beispill, bis zu 30 Sekonnen

Ier eng Feature an d'Produktioun kënnt, an dësen Deeg vu komplexen Orchestratoren an CI / CD, ass et e laange Wee fir ze goen vum Engagement op Tester a Liwwerung. Virdrun konnt Dir nei Dateien iwwer FTP eropluede (kee mécht dat méi, richteg?), An den "Deployment" Prozess huet Sekonnen gedauert. Elo musst Dir eng Fusiounsufro erstellen an eng laang Zäit waarden fir d'Feature fir d'Benotzer z'erreechen.

En Deel vun dësem Wee baut en Docker Bild. Heiansdo dauert d'Assemblée Minutten, heiansdo zéng Minutten, wat kaum normal genannt ginn ass. An dësem Artikel wäerte mir eng einfach Applikatioun huelen, déi mir an e Bild packen, verschidde Methoden uwenden fir de Bau ze beschleunegen, a kucken d'Nuancen wéi dës Methoden funktionnéieren.

Mir hu gutt Erfarung beim Schafen an Ënnerstëtzung vun Medien Websäiten: TASS, The Bell, "Nei Zeitung", Republik... Net viru laanger Zäit hu mir eise Portfolio ausgebaut andeems mir eng Produktwebsäit erausginn Erënnerung. A wärend nei Fonctiounen séier bäigefüügt goufen an al Bugs fixéiert goufen, gouf de luesen Détachement e grousse Problem.

Mir setzen op GitLab. Mir sammelen Biller, drécken se op GitLab Registry a rullen se an d'Produktioun aus. Déi längste Saach op dëser Lëscht ass Biller ze montéieren. Zum Beispill: ouni Optimisatioun huet all Backend Build 14 Minutten gedauert.

Um Enn gouf et kloer, datt mir net méi esou kënne liewen, a mir hunn eis gesat fir erauszefannen, firwat d'Biller esou laang daueren fir ze sammelen. Als Resultat hu mir et fäerdeg bruecht d'Montagezäit op 30 Sekonnen ze reduzéieren!

Fir dësen Artikel, fir net un d'Ëmfeld vun der Erënnerung gebonnen ze sinn, kucke mer e Beispill fir eng eidel Angular Applikatioun ze montéieren. Also, loosst eis eis Applikatioun erstellen:

ng n app

Füügt PWA derbäi (mir si progressiv):

ng add @angular/pwa --project app

Wärend eng Millioun npm Packagen erofgeluede ginn, loosst eis erausfannen wéi d'Docker-Bild funktionnéiert. Docker bitt d'Fäegkeet Uwendungen ze packen an se an engem isoléierten Ëmfeld ze lafen, deen e Container genannt gëtt. Dank Isolatioun kënnt Dir vill Container gläichzäiteg op engem Server lafen. Container si vill méi hell wéi virtuell Maschinnen well se direkt um Systemkär lafen. Fir e Container mat eiser Applikatioun ze lafen, musse mir als éischt e Bild erstellen an deem mir alles packen wat néideg ass fir eis Applikatioun ze lafen. Wesentlech ass e Bild eng Kopie vum Dateiesystem. Huelt zum Beispill den Dockerfile:

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

Eng Dockerfile ass eng Rei vun Instruktiounen; Wann Dir jidderee vun hinnen maacht, späichert Docker d'Ännerungen am Dateiesystem an iwwerlagert se op déi virdrun. All Team kreéiert seng eege Layer. An dat fäerdegt Bild ass Schichten kombinéiert.

Wat ass wichteg ze wëssen: all Docker Layer kann Cache. Wann näischt zënter dem leschte Build geännert huet, anstatt de Kommando auszeféieren, wäert den Docker eng fäerdeg Layer huelen. Well d'Haapterhéijung vun der Baugeschwindegkeet wéinst der Benotzung vum Cache wäert sinn, wa mir d'Baugeschwindegkeet moossen, wäerte mir speziell oppassen fir e Bild mat engem fäerdege Cache ze bauen. Also, Schrëtt fir Schrëtt:

1. Mir läschen d'Biller lokal, sou datt virdrun Lafen den Test net beaflossen.
   docker rmi $(docker images -q)
2. Mir starten de Bau fir d'éischte Kéier.
   time docker build -t app .
3. Mir änneren d'src/index.html Datei - mir imitéieren d'Aarbecht vun engem Programméierer.
4. Mir lafen de Bau eng zweete Kéier.
   time docker build -t app .

Wann d'Ëmfeld fir Biller ze bauen richteg konfiguréiert ass (méi doriwwer hei ënnen), dann wann de Bau ufänkt, wäert Docker schonn eng Rëtsch Cache u Bord hunn. Eis Aufgab ass ze léieren wéi een de Cache benotzt fir datt de Bau sou séier wéi méiglech geet. Well mir dovun ausgoen datt e Build ouni Cache nëmmen eemol geschitt - déi alleréischte Kéier - kënne mir also ignoréieren wéi lues déi éischte Kéier war. Bei Tester ass den zweete Laf vum Bau wichteg fir eis, wann d'Cache schonn opgewiermt sinn a mir bereet sinn eise Kuch ze baken. Wéi och ëmmer, e puer Tipps wäerten och den éischte Bau beaflossen.

Loosst eis den Dockerfile uewen beschriwwen am Projet Dossier setzen an de Bau starten. All Lëschte goufe kondenséiert fir d'Liesen einfach ze maachen.

$ 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

Mir änneren den Inhalt vun src/index.html a lafen et eng zweete Kéier.

$ 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

Fir ze kucken ob mir d'Bild hunn, lafen de Kommando docker images:

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

Ier Dir baut, hëlt den Docker all d'Dateien am aktuelle Kontext a schéckt se op säin Daemon Sending build context to Docker daemon 409MB. De Build Kontext gëtt als lescht Argument zum Build Kommando uginn. An eisem Fall ass dëst den aktuellen Verzeechnes - ".", - an Docker zitt alles wat mir an dësem Dossier hunn. 409 MB ass vill: loosst eis nodenken wéi et fixéiert gëtt.

Kontext reduzéieren

Fir de Kontext ze reduzéieren, ginn et zwou Méiglechkeeten. Oder setzt all d'Fichier'en, déi fir d'Assemblée gebraucht ginn, an engem getrennten Dossier a weist den Docker Kontext op dësen Dossier. Dëst ass vläicht net ëmmer bequem, also ass et méiglech Ausnahmen ze spezifizéieren: wat soll net an de Kontext geschleeft ginn. Fir dëst ze maachen, setzt d'.dockerignore-Datei an de Projet a gitt un wat net fir de Bau gebraucht gëtt:

.git
/node_modules

a lafen de Build nach eng Kéier:

$ 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 ass vill besser wéi 409 MB. Mir hunn och d'Bildgréisst vun 1.74 op 1.38 GB reduzéiert:

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

Loosst eis probéieren d'Gréisst vum Bild weider ze reduzéieren.

Mir benotzen Alpine

Eng aner Manéier fir d'Bildgréisst ze späicheren ass e klengt Elterendeel ze benotzen. D'Elterenbild ass d'Bild op Basis vun deem eist Bild virbereet ass. Déi ënnescht Schicht gëtt vum Kommando spezifizéiert FROM an Dockerfile. An eisem Fall benotze mir en Ubuntu-baséiert Bild dat schonn nodejs installéiert huet. An et waacht ...

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

... bal e Gigabyte. Dir kënnt de Volume wesentlech reduzéieren andeems Dir e Bild benotzt baséiert op Alpine Linux. Alpine ass e ganz klenge Linux. D'Docker Bild fir Nodejs baséiert op Alpine weit nëmmen 88.5 MB. Also loosst eis eist liewegt Bild an den Haiser ersetzen:

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

Mir hu missen e puer Saachen installéieren déi néideg sinn fir d'Applikatioun ze bauen. Jo, Angular baut net ouni Python ¯(°_o)/¯

Awer d'Bildgréisst ass op 150 MB erofgaang:

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

Loosst eis nach méi wäit goen.

Multistage Assemblée

Net alles wat am Bild ass wat mir an der Produktioun brauchen.

$ 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

Mat der Hëllef vun docker run app ls -lah mir lancéiert e Container baséiert op eisem Bild app an huet de Kommando an et ausgefouert ls -lah, duerno huet de Container seng Aarbecht ofgeschloss.

An der Produktioun brauche mir nëmmen en Dossier dist. An dësem Fall mussen d'Dateien iergendwéi dobausse ginn. Dir kënnt e puer HTTP-Server op nodejs lafen. Mee mir maachen et méi einfach. Guess e russescht Wuert dat véier Buschtawen "y" huet. Riets! Ynzhynyksy. Loosst eis e Bild mat nginx huelen, en Dossier dran setzen dist an eng kleng Configuratioun:

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

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

Multi-Etapp Build hëlleft eis all dëst ze maachen. Loosst eis eis Dockerfile änneren:

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 .

Elo hu mir zwee Instruktioune FROM an der Dockerfile leeft jidderee vun hinnen en anere Bauschrëtt. Mir hunn déi éischt genannt builder, mee ab dem leschten FROM, gëtt eist lescht Bild virbereet. De leschte Schrëtt ass den Artefakt vun eiser Assemblée am virege Schrëtt an dat lescht Bild mat nginx ze kopéieren. D'Gréisst vum Bild ass wesentlech erofgaang:

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

Loosst eis de Container mat eisem Bild lafen a sécherstellen datt alles funktionnéiert:

docker run -p8080:80 app

Mat der -p8080:80 Optioun hu mir den Port 8080 op eiser Hostmaschinn op den Port 80 am Container weiderginn wou nginx leeft. Open am Browser http://localhost:8080/ a mir gesinn eis Applikatioun. Alles funktionnéiert!

D'Reduktioun vun der Bildgréisst vun 1.74 GB op 36 MB reduzéiert d'Zäit wesentlech fir Är Uwendung an d'Produktioun ze liwweren. Mä loosst eis zréck op d'Versammlungszäit.

$ 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

Änneren der Uerdnung vun Schichten

Eis éischt dräi Schrëtt goufen cache (Hipp Using cache). Am véierte Schrëtt ginn all Projetdateien kopéiert an am fënnefte Schrëtt Ofhängegkeeten installéiert RUN npm ci - sou vill wéi 47.338s. Firwat all Kéier Ofhängegkeeten nei installéieren wa se ganz seelen änneren? Loosst eis erausfannen firwat se net cache goufen. De Punkt ass datt Docker Layer fir Schicht iwwerpréift fir ze kucken ob de Kommando an d'Dateien déi domat verbonne sinn geännert hunn. Um véierte Schrëtt kopéiere mir all d'Fichier'en vun eisem Projet, an ënnert hinnen sinn et natierlech Ännerungen, sou datt Docker net nëmmen dës Schicht aus dem Cache hëlt, awer och all déi duerno! Loosst eis e puer kleng Ännerungen un der Dockerfile maachen.

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 .

Als éischt ginn package.json a package-lock.json kopéiert, da ginn Ofhängegkeeten installéiert, a just duerno gëtt de ganze Projet kopéiert. Als Resultat vun:

$ 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 Sekonnen amplaz 3 Minutten - vill besser! Déi richteg Uerdnung vun de Schichten ass wichteg: als éischt kopéiere mir dat wat net ännert, dann wat selten ännert, a schliisslech wat ännert sech dacks.

Als nächst, e puer Wierder iwwer d'Versammlung vun Biller an CI / CD Systemer.

Benotzt virdrun Biller fir Cache

Wa mir eng Aart SaaS Léisung fir de Bau benotzen, da kann de lokalen Docker Cache propper a frësch sinn. Fir dem Docker eng Plaz ze ginn fir déi gebakene Schichten ze kréien, gitt him dat viregt gebaute Bild.

Loosst eis e Beispill huelen fir eis Applikatioun an GitHub Actions ze bauen. Mir benotzen dës Configuratioun

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

D'Bild gëtt zesummegesat an op GitHub Packages an zwou Minutten an 20 Sekonnen gedréckt:

Loosst eis elo de Bau änneren sou datt e Cache benotzt gëtt baséiert op fréiere gebaute Biller:

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

Als éischt musse mir Iech soen firwat zwee Kommandoen lancéiert ginn build. D'Tatsaach ass datt an enger Multistage Assemblée dat entstinn Bild eng Rei vu Schichten aus der leschter Stuf ass. An dësem Fall sinn Schichten aus fréiere Schichten net am Bild abegraff. Dofir, wann Dir dat lescht Bild vun engem fréiere Build benotzt, wäert Docker net fäerdeg Schichten fannen fir d'Bild mat Nodejs ze bauen (Builder Bühn). Fir dëse Problem ze léisen, gëtt e Mëttelbild erstallt $IMAGE_NAME-builder-stage a gëtt op GitHub Packages gedréckt sou datt et an engem spéideren Build als Cachequell benotzt ka ginn.

D'total Versammlungszäit gouf op eng an eng hallef Minutt reduzéiert. Eng hallef Minutt gëtt verbruecht fir virdrun Biller opzezéien.

Preimaging

Eng aner Manéier fir de Problem vun engem propperen Docker Cache ze léisen ass e puer vun de Schichten an eng aner Dockerfile ze réckelen, se separat ze bauen, se an d'Container Registry drécken a se als Elterendeel benotzen.

Mir kreéieren eisen eegene Nodejs Bild fir eng Angular Applikatioun ze bauen. Erstellt Dockerfile.node am Projet

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

Mir sammelen a drécken en ëffentlecht Bild am Docker Hub:

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

Elo an eisem Haapt Dockerfile benotze mir dat fäerdegt Bild:

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

An eisem Beispill ass d'Bauzäit net erofgaang, awer pre-built Biller kënnen nëtzlech sinn wann Dir vill Projeten hutt an déiselwecht Ofhängegkeeten an all eenzel vun hinnen installéiere musst.

Mir hunn e puer Methoden gekuckt fir de Bau vun Docker-Biller ze beschleunegen. Wann Dir wëllt datt d'Deployment séier geet, probéiert dëst an Ärem Projet ze benotzen:

• Kontext reduzéieren;
• Benotzung vu klenge Elteren Biller;
• Multistage Assemblée;
• d'Uerdnung vun den Instruktiounen an der Dockerfile änneren fir effizient Notzung vum Cache ze maachen;
• Astellung vun engem Cache an CI / CD Systemer;
• virleefeg Kreatioun vu Biller.

Ech hoffen d'Beispill wäert et méi kloer maachen wéi Docker funktionnéiert, an Dir kënnt Är Deployment optimal konfiguréieren. Fir mat de Beispiller aus dem Artikel ze spillen, gouf e Repository erstallt https://github.com/devopsprodigy/test-docker-build.

Source: will.com