ProHoster > Blog > Rêveberî > Ji bo Serlêdanek Boota Biharê Wêneyên Dokera Optimîzekirî ava dikin

Ji bo Serlêdanek Boota Biharê Wêneyên Dokera Optimîzekirî ava dikin

Konteyniran bûne navgînên bijarte yên pakkirina serîlêdanek bi hemî nermalava wê û pêwendiya pergala xebitandinê û dûv re gihandina wan ji hawîrdorên cihêreng.

Ev gotar awayên cihêreng ên ji bo konteynirkirina serîlêdana Spring Boot vedigire:

  • avakirina wêneyek docker bi karanîna dockerfile,
  • avakirina wêneyek OCI ji çavkaniyê bi karanîna Cloud-Native Buildpack,
  • û xweşbînkirina wêneyê di dema xebitandinê de bi veqetandina beşên JAR-ê di astên cihêreng de bi karanîna amûrên qatkirî.

 Nimûneya kodê

Ev gotar bi mînakek koda xebatê ve tê li ser GitHub .

Termînolojiya konteyner

Em ê bi termînolojiya konteynerê ku li seranserê gotarê tê bikar anîn dest pê bikin:

  • Wêneyê konteyner: pelek bi formatek taybetî. Em bi xebitandina amûra avakirinê serîlêdana xwe vediguhezînin wêneyek konteynerê.
  • Container: Nimûneyek pêkan a wêneya konteynerê.
  • Motora konteyner: Pêvajoya daemonê ku berpirsiyarê xebitandina konteynerê ye.
  • Hostayê konteyner: Makîneya mêvandar ku motora konteynerê li ser dixebitîne.
  • Registry konteynir: Cihê giştî ku ji bo weşandin û belavkirina wêneya konteynerê tê bikar anîn.
  • standard OCI: Înîsiyatîfa Konteynirê Vekirî (OCI) çarçoveyek rêveberiya sivik, çavkaniya vekirî ye ku ji hêla Weqfa Linux ve hatî çêkirin. Taybetmendiya Wêneyê OCI standardên pîşesaziyê ji bo formatên wêneya konteynerê û dema xebitandinê diyar dike da ku pê ewle bibe ku hemî motorên konteyneran dikarin wêneyên konteynerê yên ku ji hêla her amûrek çêkirinê ve hatine afirandin bimeşînin.

Ji bo ku serîlêdanek konteynir bikin, em serîlêdana xwe di wêneyek konteynerê de dipêçin û wê wêneyê di qeyda giştî de diweşînin. Dema xebitandina konteyneran vê wêneyê ji qeydê vedigire, jê vedike û sepanê di hundurê wê de dimeşîne.

Guhertoya 2.3 ya Spring Boot ji bo avakirina wêneyên OCI pêvekan peyda dike.

Docker pêkanîna konteynerê ya ku bi gelemperî tê bikar anîn e, û em di mînakên xwe de Docker bikar tînin, ji ber vê yekê hemî referansên konteynerê yên paşîn ên di vê gotarê de dê serî li Docker bidin.

Avakirina wêneyek konteynerê bi awayê kevneşopî

Afirandina wêneyên Docker-ê ji bo sepanên Spring Boot bi lê zêdekirina çend rêwerzan li pelê Docker pir hêsan e.

Em pêşî pelek JAR-ê ya darvekirî diafirînin û, wekî beşek ji rêwerzên pelê Docker-ê, piştî ku mîhengên pêwîst bicîh bînin, pelê JAR-a îcrakar li ser wêneya bingehîn JRE kopî bikin.

Werin em serîlêdana xweya Biharê li ser biafirînin Bihar Initializr bi girêdayîbûnên web, lombokи actuator. Em di heman demê de kontrolkerek mayî jî lê zêde dikin da ku API-yê pê re peyda bikin GETawa.

Afirandina Dockerfile

Dûv re em vê serîlêdanê bi lêzêdekirinê di konteynirekê de bi cih dikin Dockerfile:

FROM adoptopenjdk:11-jre-hotspot
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} application.jar
EXPOSE 8080
ENTRYPOINT ["java","-jar","/application.jar"]

Dockerfile me wêneyek bingehîn heye, ji adoptopenjdk, li ser vê yekê em pelê xweya JAR kopî dikin û paşê portê vedikin, 8080ku dê guh bide daxwazan.

Meclîsa Serîlêdanê

Pêşî hûn hewce ne ku bi karanîna Maven an Gradle serîlêdanek çêbikin. Li vir em Maven bikar tînin:

mvn clean package

Ev ji bo serîlêdanê pelek JAR-ê ya darvekirî diafirîne. Pêdivî ye ku em vê JAR-a îcrakar veguherînin wêneyek Docker ku li ser motora Docker-ê bixebite.

Afirandina wêneyek konteynerê

Dûv re em vê pelê JAR-a îcrakar bi xebitandina fermanê têxin nav wêneya Docker docker buildji pelrêça root ya projeyê ku Dockerfile berê hatî afirandin heye:

docker build  -t usersignup:v1 .

Em dikarin wêneyê xwe di navnîşê de bi fermanê bibînin:

docker images

Derketina fermana jorîn wêneyê me vedihewîne usersignupligel wêneya bingehîn, adoptopenjdkdi Dockerfile me de hatî destnîşan kirin.

REPOSITORY          TAG                 SIZE
usersignup          v1                  249MB
adoptopenjdk        11-jre-hotspot      229MB

Li qatan di hundurê wêneyek konteynerê de temaşe bikin

Ka em li stûna qatên hundurê wêneyê binêrin. Em ê bikar bînin amûr  navdeçûn, ji bo dîtina van qatan:

dive usersignup:v1

Li vir beşek ji derketina fermana Dive ye: 

Ji bo Serlêdanek Boota Biharê Wêneyên Dokera Optimîzekirî ava dikin

Wekî ku em dibînin, qata serîlêdanê beşek girîng a mezinahiya wêneyê pêk tîne. Em dixwazin di beşên jêrîn de wekî beşek ji xweşbîniya xwe mezinahiya vê qatê kêm bikin.

Bi Buildpack re wêneyek konteynerê ava bikin

pakêtên Meclîsa (Buildpacks) peyvek gelemperî ye ku ji hêla platformên cihêreng ên wekî karûbar (PAAS) ve tê bikar anîn da ku wêneyek konteynerê ji koda çavkaniyê biafirîne. Ew ji hêla Heroku ve di 2011-an de hate destpêkirin û ji hingê ve ji hêla Cloud Foundry, Google App Engine, Gitlab, Knative û çend kesên din ve hatî pejirandin.

Ji bo Serlêdanek Boota Biharê Wêneyên Dokera Optimîzekirî ava dikin

Avantajên pakêtên Cloud Build

Yek ji feydeyên sereke yên karanîna Buildpack ji bo çêkirina wêneyan ew e Guhertinên veavakirina wêneyê dikare bi navendî (avakar) were rêvebirin û li hemî serîlêdanên ku çêker bikar tînin were belav kirin.

Pakêtên çêkirinê bi platformê re hişk bûn. Cloud-Native Buildpacks bi piştgirîkirina formata wêneya OCI, standardîzekirinê li seranserê platforman peyda dike, ku piştrast dike ku wêne dikare ji hêla motora Docker ve were rêve kirin.

Bikaranîna Pêveka Spring Boot

Pêveka Spring Boot wêneyên OCI ji çavkaniyê bi karanîna Buildpack ava dike. Wêneyên bi karanîna têne çêkirin bootBuildImageerkên (Gradle) an spring-boot:build-imagearmanc (Maven) û sazkirina Docker ya herêmî.

Em dikarin navê wêneyê ku em hewce ne ku bi qeydkirina Docker ve bişînin bi danasîna navê xwe xweş bikin. image tag:

<plugin>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-maven-plugin</artifactId>
  <configuration>
    <image>
      <name>docker.io/pratikdas/${project.artifactId}:v1</name>
    </image>
  </configuration>
</plugin>

Ka em Maven bikar bînin da ku darve bikin build-imagearmancên ji bo afirandina serîlêdanek û afirandina wêneyek konteynerê. Em vê gavê tu Dockerfiles bikar naynin.

mvn spring-boot:build-image

Encam dê tiştek wiha be:

[INFO] --- spring-boot-maven-plugin:2.3.3.RELEASE:build-image (default-cli) @ usersignup ---
[INFO] Building image 'docker.io/pratikdas/usersignup:v1'
[INFO] 
[INFO]  > Pulling builder image 'gcr.io/paketo-buildpacks/builder:base-platform-api-0.3' 0%
.
.
.. [creator]     Adding label 'org.springframework.boot.version'
.. [creator]     *** Images (c311fe74ec73):
.. [creator]           docker.io/pratikdas/usersignup:v1
[INFO] 
[INFO] Successfully built image 'docker.io/pratikdas/usersignup:v1'

Ji encam, em dibînin ku paketo Cloud-Native buildpackji bo afirandina wêneyek OCI ya xebatê tê bikar anîn. Mîna berê, em dikarin wêneya ku wekî wêneyek Docker hatî navnîş kirin bi fermanê re bibînin:

docker images

Encam:

REPOSITORY                             SIZE
paketobuildpacks/run                  84.3MB
gcr.io/paketo-buildpacks/builder      652MB
pratikdas/usersignup                  257MB

Afirandina wêneyek konteyner bi Jib

Jib pêvekek nivîsandina wêneyê ji Google-ê ye ku rêbazek alternatîf a afirandina wêneyek konteynerê ji çavkaniyê peyda dike.

Sazkirin jib-maven-plugindi pom.xml:

      <plugin>
        <groupId>com.google.cloud.tools</groupId>
        <artifactId>jib-maven-plugin</artifactId>
        <version>2.5.2</version>
      </plugin>

Dûv re, em pêveka Jib bi karanîna fermana Maven dimeşînin da ku serîlêdanê ava bikin û wêneya konteynerê biafirînin. Mîna berê, em li vir tu Dockerfiles bikar naynin:

mvn compile jib:build -Dimage=<docker registry name>/usersignup:v1

Piştî ku emrê jorîn Maven bicîh anîn, em encamek jêrîn digirin:

[INFO] Containerizing application to pratikdas/usersignup:v1...
.
.
[INFO] Container entrypoint set to [java, -cp, /app/resources:/app/classes:/app/libs/*, io.pratik.users.UsersignupApplication]
[INFO] 
[INFO] Built and pushed image as pratikdas/usersignup:v1
[INFO] Executing tasks:
[INFO] [==============================] 100.0% complete

Hilber nîşan dide ku wêneya konteynerê hatiye afirandin û di qeydê de cih digire.

Motivasyon û rêbazên ji bo afirandina wêneyên xweşbînkirî

Du sedemên me yên sereke ji bo xweşbîniyê hene:

  • Berhemdariyê: Di pergalek orkestrasyona konteynerê de, wêneyek konteynerê ji qeyda wêneyê berbi mêvandarê ku motora konteynerê dixebitîne tê kişandin. Ji vê pêvajoyê re plansazkirin tê gotin. Kişandina wêneyên mezin ji qeydê di pergalên orkestrasyona konteynerê de demên plansazkirinê yên dirêj û di boriyên CI-yê de demên çêkirinê yên dirêj vedigire.
  • Ewlekariyê: wêneyên mezin di heman demê de ji bo qelsiyan deverek mezin heye.

Wêneyek Docker ji stûnek qatan pêk tê, ku her yek di Dockerfile me de daxuyaniyek temsîl dike. Her qatek deltaya guherînên di qata binî de temsîl dike. Gava ku em wêneyek Docker ji qeydê derdixin, ew di qatan de tê kişandin û li ser mêvandar tê girtin.

Spring Boot bikar tîne "JAR qelew" tê de wekî forma pakkirinê ya xwerû. Dema ku em li JARek qelew dinêrin, em dibînin ku serîlêdan beşek pir piçûk a tevahiya JAR-ê ye. Ev beşa ku herî zêde diguhere ye. Ya mayî ji girêdanên Çarçoveya Biharê pêk tê.

Formula xweşbîniyê li dor veqetandina serîlêdanê di astek cihêreng de ji girêdayîbûna Çarçoveya Biharê ye.

Parçeya girêdayîbûnê ya ku piraniya pelê JAR-a qalind pêk tîne tenê carekê tê dakêşandin û li ser pergala mêvandar tê girtin.

Di dema nûvekirinên serîlêdanê û plansazkirina konteynerê de tenê qatek zirav a sepanê tê kişandin, wek ku di vê diagramê de tê nîşandan:

Ji bo Serlêdanek Boota Biharê Wêneyên Dokera Optimîzekirî ava dikin

Di beşên jêrîn de, em ê binihêrin ka meriv çawa van wêneyên xweşbînkirî ji bo serîlêdanek Spring Boot biafirîne.

Afirandina wêneyek konteynerê xweşbînkirî ji bo serîlêdanek biharê bi karanîna Buildpack

Spring Boot 2.3 bi derxistina parçeyên pelê JAR-a qalind di qatên cihêreng de, qatkirinê piştgirî dike. Taybetmendiya qatkirinê ji hêla xwerû ve neçalak e û pêdivî ye ku bi karanîna pêveka Spring Boot Maven bi eşkere were çalak kirin:

<plugin>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-maven-plugin</artifactId>
  <configuration>
    <layers>
      <enabled>true</enabled>
    </layers>
  </configuration> 
</plugin>

Em ê vê veavakirinê bikar bînin da ku wêneya konteynera xwe pêşî bi Buildpack û dûv re jî bi Docker re di beşên jêrîn de ava bikin.

Em birevin build-imageMaven armanc dike ku wêneyek konteynerek biafirîne:

mvn spring-boot:build-image

Ger em Dive-ê bimeşînin da ku qatan di wêneya encam de bibînin, em dikarin bibînin ku qata serîlêdanê (bi rengê sor hatî dorpêç kirin) li gorî ya ku me bi karanîna formata JAR-a qalind girtiye, di rêza kilobyte de pir piçûktir e:

Ji bo Serlêdanek Boota Biharê Wêneyên Dokera Optimîzekirî ava dikin

Ji bo Serlêdanek Boot-a Biharê bi Docker re wêneyek konteynerê xweşbînkirî ava kirin

Li şûna ku em pêvekek Maven an Gradle bikar bînin, em dikarin bi pelek Docker re wêneyek Docker JAR-a qat biafirînin.

Dema ku em Docker bikar tînin, divê em du gavên zêde bavêjin da ku qatan derxînin û wan di wêneya paşîn de kopî bikin.

Naveroka JAR-a ku di encamê de piştî avakirina bi Maven-ê bi qat-belavkirinê ve hatî çalak kirin dê bi vî rengî xuya bike:

META-INF/
.
BOOT-INF/lib/
.
BOOT-INF/lib/spring-boot-jarmode-layertools-2.3.3.RELEASE.jar
BOOT-INF/classpath.idx
BOOT-INF/layers.idx

Hilber JARek din a bi navê xwe nîşan dide spring-boot-jarmode-layertoolsи layersfle.idxdosî. Vê pelê JAR-ê ya din kapasîteyên pêvajoyek qatkirî peyda dike, wekî ku di beşa paşîn de hatî destnîşan kirin.

Girêdanên li ser qatên cihêreng derxînin

Ji bo dîtin û derxistina qatan ji JAR-a meya qatkirî, em taybetmendiya pergalê bikar tînin -Djarmode=layertoolsji bo destpêkê spring-boot-jarmode-layertoolsJAR li şûna serîlêdanê:

java -Djarmode=layertools -jar target/usersignup-0.0.1-SNAPSHOT.jar

Bi xebitandina vê fermanê encamek ku vebijarkên fermanê yên berdest vedihewîne çêdike:

Usage:
  java -Djarmode=layertools -jar usersignup-0.0.1-SNAPSHOT.jar

Available commands:
  list     List layers from the jar that can be extracted
  extract  Extracts layers from the jar for image creation
  help     Help about any command

Hilbera fermanan nîşan dide list, extractи helpс helpdefault be. Werin em bi fermanê bimeşînin listdibe:

java -Djarmode=layertools -jar target/usersignup-0.0.1-SNAPSHOT.jar list
dependencies
spring-boot-loader
snapshot-dependencies
application

Em navnîşek girêdanên ku dikarin wekî qatan werin zêdekirin dibînin.

Ji hêla xwerû ve qat:

Navê qatê

Contains

dependencies

her pêwendiyek ku guhertoya wê SNAPSHOT nagire

spring-boot-loader

Dersên JAR Loader

snapshot-dependencies

her girêdayîbûna ku guhertoya wê SNAPSHOT heye

application

çînên sepanê û çavkaniyên

Qat di nav de têne diyar kirin layers.idxpelê bi rêza ku divê ew li wêneya Docker werin zêdekirin. Van qatan piştî girtina yekem li ser mêvandar têne cach kirin ji ber ku ew naguherin. Tenê qata serîlêdanê ya nûvekirî ji mêvandar re tê dakêşandin, ku ji ber kêmbûna mezinbûnê zûtir e .

Avakirina wêneyek bi girêdanên ku di qatên cuda de têne derxistin

Em ê wêneya paşîn di du gavan de bi karanîna rêbazek bi navê ava bikin civîna pir-qonaxa . Di gava yekem de em ê girêdanan derxînin û di gava duyemîn de jî em ê girêdanên hatine derxistin di dawiya dawîn de kopî bikin.

Werin em Dockerfile xwe ji bo avakirina pir-qonaxa biguherînin:

# the first stage of our build will extract the layers
FROM adoptopenjdk:14-jre-hotspot as builder
WORKDIR application
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} application.jar
RUN java -Djarmode=layertools -jar application.jar extract

# the second stage of our build will copy the extracted layers
FROM adoptopenjdk:14-jre-hotspot
WORKDIR application
COPY --from=builder application/dependencies/ ./
COPY --from=builder application/spring-boot-loader/ ./
COPY --from=builder application/snapshot-dependencies/ ./
COPY --from=builder application/application/ ./
ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]

Em vê veavakirinê di pelek cûda de hilînin - Dockerfile2.

Em bi karanîna fermanê wêneya Docker ava dikin:

docker build -f Dockerfile2 -t usersignup:v1 .

Piştî pêkanîna vê fermanê, em encamek jêrîn digirin:

Sending build context to Docker daemon  20.41MB
Step 1/12 : FROM adoptopenjdk:14-jre-hotspot as builder
14-jre-hotspot: Pulling from library/adoptopenjdk
.
.
Successfully built a9ebf6970841
Successfully tagged userssignup:v1

Em dikarin bibînin ku wêneya Docker bi nasnameyeke wêneyê ve hatî afirandin û dûv re tê nîşankirin.

Di dawiyê de, em wekî berê fermana Dive dimeşînin da ku qatên di hundurê wêneya Docker-a hatî hilberandin de binihêrin. Em dikarin wekî têketina fermana Dive nasnameyek wêneyek an nîşanek peyda bikin:

dive userssignup:v1

Wekî ku hûn ji derketinê jî dibînin, qata ku serîlêdanê vedihewîne naha tenê 11 KB ye û ve girêdayî di qatên cihê de têne girtin. 

Ji bo Serlêdanek Boota Biharê Wêneyên Dokera Optimîzekirî ava dikin

Girêdanên navxweyî li ser qatên cihêreng derxînin

Em dikarin bi derxistina yek ji girêdanên xwerû yên xwerû di qatek cihêreng de li şûna ku em wan bi serîlêdanê re bi ragihandina wan di nav de pak bikin, mezinahiya qata serîlêdanê kêm bikin. ymlpelê wekhev bi navê layers.idx:

- "dependencies":
  - "BOOT-INF/lib/"
- "spring-boot-loader":
  - "org/"
- "snapshot-dependencies":
- "custom-dependencies":
  - "io/myorg/"
- "application":
  - "BOOT-INF/classes/"
  - "BOOT-INF/classpath.idx"
  - "BOOT-INF/layers.idx"
  - "META-INF/"

Di vê pelê de layers.idxme pêwendiyek xwerû ya bi navê, io.myorggirêdanên rêxistinê yên ku ji depoya hevbeş hatine derxistin vedihewîne.

encamê

Di vê gotarê de, me li karanîna Cloud-Native Buildpacks nihêrî ku rasterast ji çavkaniyê wêneyek konteynerê ava bikin. Ev alternatîfek ji karanîna Docker-ê ye ku wêneyek konteynerê bi awayê asayî biafirîne: yekem, pelek JAR-a darvekirî ya stûr tê afirandin û dûv re bi destnîşankirina rêwerzên di Dockerfile de di nav wêneyek konteynerê de tê pak kirin.

Di heman demê de me li xweşbînkirina konteynera xwe nihêrî ku bi tevlêbûna taybetmendiyek qatkirinê ya ku girêdayîbûnê di qatên cihêreng ên ku li ser mêvandar têne vegirtin vediqetîne û qatek serîlêdanê ya zirav di dema plansazkirinê de di motorên darvekirina konteynerê de tê barkirin.

Hûn dikarin hemî koda çavkaniyê ku di gotarê de têne bikar anîn li vir bibînin Github .

Referansa fermanê

Li vir kurteyek fermanên ku me di vê gotarê de bikar anîn ji bo referansek bilez heye.

Paqijkirina naverokê:

docker system prune -a

Avakirina wêneyek konteynerek bi Dockerfile:

docker build -f <Docker file name> -t <tag> .

Wêneyê konteynerê ji çavkaniyê ava bikin (bêyî Dockerfile):

mvn spring-boot:build-image

Tebeqên girêdayîbûnê bibînin. Berî avakirina pelê jar-ê ya serîlêdanê, pê ewle bine ku taybetmendiya qatkirinê di pêveka spring-boot-maven-de çalak e:

java -Djarmode=layertools -jar application.jar list

Tebeqeyên girêdayîbûnê derxînin. Berî avakirina pelê jar-ê ya serîlêdanê, pê ewle bine ku taybetmendiya qatkirinê di pêveka spring-boot-maven-de çalak e:

 java -Djarmode=layertools -jar application.jar extract

Dîtina Lîsteya Wêneyên Konteyner

docker images

Li milê çepê di hundurê wêneya konteynerê de binihêrin (pê bawer bin ku amûra dive hatî saz kirin):

dive <image ID or image tag>

Source: www.habr.com