🥇Spring Boot යෙදුම සඳහා ප්‍රශස්ත ඩොකර් රූප සාදන්න

යෙදුමක් එහි සියලුම මෘදුකාංග සහ මෙහෙයුම් පද්ධති පරායත්තතා සමඟ ඇසුරුම් කර විවිධ පරිසරයන් වෙත ඒවා ලබා දීම සඳහා බහාලුම් වඩාත් කැමති මාධ්‍යයක් බවට පත්ව ඇත.

මෙම ලිපිය Spring Boot යෙදුමක් බහාලුම් කිරීමට විවිධ ක්රම ආවරණය කරයි:

ඩොකර් ගොනුවක් භාවිතයෙන් ඩොකර් රූපයක් තැනීම,
Cloud-Native Buildpack භාවිතයෙන් මූලාශ්‍රයෙන් OCI රූපයක් ගොඩනැගීම,
සහ ස්ථර මෙවලම් භාවිතයෙන් JAR කොටස් විවිධ මට්ටම්වලට වෙන් කිරීමෙන් ධාවන වේලාවේදී රූප ප්‍රශස්තකරණය.

කේත උදාහරණය

මෙම ලිපිය වැඩ කරන කේත උදාහරණයක් සමඟ ඇත GitHub මත .

බහාලුම් පාරිභාෂිතය

අපි ලිපිය පුරා භාවිතා කරන බහාලුම් පාරිභාෂිතය සමඟ ආරම්භ කරමු:

බහාලුම් රූපය: නිශ්චිත ආකෘතියක ගොනුවක්. ගොඩනැගීමේ මෙවලම ක්‍රියාත්මක කිරීමෙන් අපි අපගේ යෙදුම බහාලුම් රූපයක් බවට පරිවර්තනය කරමු.
කන්ටේනර්: බහාලුම් රූපයේ ක්‍රියාත්මක කළ හැකි අවස්ථාවක්.
බහාලුම් එන්ජිම: බහාලුම් ධාවනය සඳහා වගකිව යුතු ඩීමන් ක්රියාවලිය.
බහාලුම් සත්කාරක: බහාලුම් එන්ජිම ක්‍රියාත්මක වන ධාරක යන්ත්‍රය.
බහාලුම් රෙජිස්ට්රි: බහාලුම් රූපය ප්‍රකාශයට පත් කිරීමට සහ බෙදා හැරීමට භාවිතා කරන සාමාන්‍ය ස්ථානය.
OCI සම්මතය: විවෘත බහාලුම් මුලපිරීම (OCI) ලිනක්ස් පදනම විසින් පිහිටුවන ලද සැහැල්ලු, විවෘත මූලාශ්‍ර කළමනාකරණ රාමුවකි. OCI රූප පිරිවිතරය බහාලුම් රූප ආකෘති සඳහා කර්මාන්ත ප්‍රමිතීන් සහ සියලුම බහාලුම් එන්ජින්වලට ඕනෑම ගොඩනැගීමේ මෙවලමක් මඟින් සාදන ලද බහාලුම් රූප ධාවනය කළ හැකි බව සහතික කිරීම සඳහා ධාවන කාලය නිර්වචනය කරයි.

යෙදුමක් බහාලුම් කිරීමට, අපි අපගේ යෙදුම බහාලුම් රූපයක ඔතා එම රූපය පොදු ලේඛනයට ප්‍රකාශයට පත් කරමු. බහාලුම් ධාවන කාලය මෙම රූපය රෙජිස්ට්‍රියෙන් ලබාගෙන, එය අසුරා, එය තුළ යෙදුම ධාවනය කරයි.

Spring Boot හි 2.3 අනුවාදය OCI රූප ගොඩනැගීම සඳහා ප්ලගීන සපයයි.

Docker වඩාත් බහුලව භාවිතා වන බහාලුම් ක්‍රියාත්මක කිරීම වන අතර, අපි අපගේ උදාහරණවල ඩොකර් භාවිතා කරමු, එබැවින් මෙම ලිපියේ සියලුම පසුකාලීන බහාලුම් යොමු කිරීම් ඩොකර් වෙත යොමු වේ.

සාම්ප්රදායික ආකාරයෙන් බහාලුම් රූපයක් ගොඩනැගීම

Spring Boot යෙදුම් සඳහා Docker images ගොඩනැගීම ඔබගේ Dockerfile වෙත උපදෙස් කිහිපයක් එක් කිරීමෙන් ඉතා පහසු වේ.

අපි මුලින්ම ක්‍රියාත්මක කළ හැකි JAR එකක් සාදන අතර, Dockerfile උපදෙස්වල කොටසක් ලෙස, අවශ්‍ය අභිරුචිකරණයන් යෙදීමෙන් පසු පාදක JRE රූපයට ඉහළින් ක්‍රියාත්මක කළ හැකි JAR පිටපත් කරන්න.

අපි අපේ වසන්ත යෙදුම නිර්මාණය කරමු වසන්තයේ ආරම්භය පරායත්තතා සමඟ web, lombokи actuator. අපි API එකක් සැපයීම සඳහා විවේක පාලකයක් ද එකතු කරමු GETක්රමය.

Dockerfile නිර්මාණය කිරීම

ඉන්පසු අපි මෙම යෙදුම එකතු කිරීමෙන් කන්ටේනරයක තබමු Dockerfile:

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

අපගේ Dockerfile හි මූලික රූපයක් අඩංගු වේ adoptopenjdk, ඊට උඩින් අපි අපේ JAR ගොනුව පිටපත් කර වරාය විවෘත කරන්න, 8080ඉල්ලීම් සඳහා සවන් දෙනු ඇත.

යෙදුම් එකලස් කිරීම

මුලින්ම ඔබ Maven හෝ Gradle භාවිතයෙන් යෙදුමක් නිර්මාණය කළ යුතුය. මෙන්න අපි Maven භාවිතා කරනවා:

mvn clean package

මෙය යෙදුම සඳහා ක්‍රියාත්මක කළ හැකි JAR ගොනුවක් නිර්මාණය කරයි. අපි මෙම ක්‍රියාත්මක කළ හැකි JAR ඩොකර් එන්ජිම මත ක්‍රියාත්මක වීමට ඩොකර් රූපයක් බවට පරිවර්තනය කළ යුතුයි.

බහාලුම් රූපයක් සාදන්න

ඉන්පසු අපි මෙම JAR ක්‍රියාත්මක කළ හැකි විධානය ක්‍රියාත්මක කිරීමෙන් ඩොකර් රූපයට දමමු docker buildකලින් සාදන ලද Dockerfile අඩංගු ව්‍යාපෘතියේ මූල නාමාවලියෙන්:

docker build  -t usersignup:v1 .

විධානය සමඟ ලැයිස්තුවේ අපගේ රූපය අපට දැකිය හැකිය:

docker images

ඉහත විධානයේ ප්‍රතිදානය අපගේ රූපය ඇතුළත් වේ usersignupමූලික රූපය සමඟ, adoptopenjdkඅපගේ Dockerfile හි නිශ්චිතව දක්වා ඇත.

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

බහාලුම් රූපයක් ඇතුළත ස්ථර බලන්න

අපි බලමු රූපයේ ඇතුලේ තියෙන ස්තර තොගය. අපි භාවිතා කරන්නෙමු මෙවලම කිමිදෙනවා, මෙම ස්ථර බැලීමට:

dive usersignup:v1

ඩයිව් විධානයේ ප්‍රතිදානයේ කොටසක් මෙන්න:

අපට පෙනෙන පරිදි, යෙදුම් ස්තරය රූපයේ ප්‍රමාණයෙන් සැලකිය යුතු කොටසක් සාදයි. අපගේ ප්‍රශස්තකරණයේ කොටසක් ලෙස පහත කොටස්වල මෙම ස්ථරයේ ප්‍රමාණය අඩු කිරීමට අපට අවශ්‍යය.

Buildpack සමඟ බහාලුම් රූපයක් ගොඩනැගීම

එකලස් කිරීමේ පැකේජ (බිල්ඩ්පැක්) යනු මූලාශ්‍ර කේතයෙන් බහාලුම් රූපයක් නිර්මාණය කිරීම සඳහා සේවා (PAAS) පිරිනැමීම් ලෙස විවිධ වේදිකාව විසින් භාවිතා කරන සාමාන්‍ය පදයකි. එය 2011 හි Heroku විසින් දියත් කරන ලද අතර එතැන් සිට Cloud Foundry, Google App Engine, Gitlab, Knative සහ තවත් කිහිපයක් විසින් එය සම්මත කර ඇත.

Cloud Build Packages වල වාසිය

පින්තූර තැනීමට Buildpack භාවිතා කිරීමේ ප්‍රධාන වාසියක් වන්නේ එයයි රූප වින්‍යාස වෙනස් කිරීම් මධ්‍යගතව (බිල්ඩර්) කළමනාකරණය කළ හැකි අතර ගොඩනඟන්නා භාවිතයෙන් සියලුම යෙදුම් වෙත ප්‍රචාරණය කළ හැක.

ගොඩ නැගීමේ පැකේජ වේදිකාවට සමීපව බැඳී ඇත. Cloud-Native Buildpacks OCI රූප ආකෘතියට සහය දක්වමින් වේදිකා හරහා ප්‍රමිතිකරණය සපයයි, එමඟින් රූපය ඩොකර් එන්ජිම මඟින් ධාවනය කළ හැකි බව සහතික කරයි.

Spring Boot ප්ලගිනය භාවිතා කිරීම

Spring Boot ප්ලගිනය Buildpack භාවිතයෙන් මූලාශ්‍රයෙන් OCI රූප ගොඩනඟයි. භාවිතයෙන් රූප නිර්මාණය කර ඇත bootBuildImageකාර්යයන් (Gradle) හෝ spring-boot:build-imageඉලක්කය (Maven) සහ දේශීය ඩොකර් ස්ථාපනය.

අපට ඩොකර් රෙජිස්ට්‍රියට තල්ලු කිරීමට අවශ්‍ය රූපයේ නම සඳහන් කිරීමෙන් අපට අභිරුචිකරණය කළ හැකිය. 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>

ක්‍රියාත්මක කිරීමට Maven භාවිතා කරමු build-imageයෙදුමක් නිර්මාණය කිරීම සහ බහාලුම් රූපයක් නිර්මාණය කිරීම සඳහා ඉලක්ක. අපි දැනට කිසිම Dockerfiles භාවිතා කරන්නේ නැහැ.

mvn spring-boot:build-image

ප්රතිඵලය මේ වගේ දෙයක් වනු ඇත:

[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'

නිමැවුමෙන්, අපට එය පෙනේ paketo Cloud-Native buildpackවැඩ කරන OCI රූපයක් නිර්මාණය කිරීමට භාවිතා කරයි. පෙර පරිදි, විධානය ක්‍රියාත්මක කිරීමෙන් අපට ඩොකර් රූපයක් ලෙස ලැයිස්තුගත කර ඇති රූපය දැකිය හැකිය:

docker images

නිගමනය:

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

Jib භාවිතයෙන් බහාලුම් රූපයක් නිර්මාණය කිරීම

Jib යනු ප්‍රභවයෙන් බහාලුම් රූපයක් සෑදීමේ විකල්ප ක්‍රමයක් සපයන Google වෙතින් වන පින්තූර කර්තෘ ප්ලගිනයකි.

අභිරුචිකරණය කරන්න jib-maven-pluginpom.xml හි:

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

මීලඟට, අපි යෙදුම ගොඩනැගීමට සහ බහාලුම් රූපය නිර්මාණය කිරීමට Maven විධානය භාවිතා කරමින් Jib ප්ලගිනය ධාවනය කරමු. පෙර මෙන්, අපි මෙහි කිසිදු Dockerfiles භාවිතා නොකරමු:

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

ඉහත Maven විධානය ක්‍රියාත්මක කිරීමෙන් පසු, අපට පහත ප්‍රතිදානය ලැබේ:

[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

ප්‍රතිදානය පෙන්නුම් කරන්නේ බහාලුම් රූපය නිර්මාණය කර රෙජිස්ට්‍රියේ තබා ඇති බවයි.

ප්‍රශස්ත රූප නිර්මාණය කිරීම සඳහා අභිප්‍රේරණ සහ ක්‍රම

ප්‍රශස්ත කිරීම සඳහා අපට ප්‍රධාන හේතු දෙකක් තිබේ:

ඵලදායිතාව: බහාලුම් වාද්‍ය වෘන්ද පද්ධතියක, බහාලුම් රූපයක් රූප රෙජිස්ට්‍රියේ සිට බහාලුම් එන්ජිම ක්‍රියාත්මක වන ධාරකයට ඇද දමනු ලැබේ. මෙම ක්රියාවලිය සැලසුම් කිරීම ලෙස හැඳින්වේ. රෙජිස්ට්‍රියෙන් විශාල රූප ඇදීමෙන් බහාලුම් වාද්‍ය වෘන්ද පද්ධතිවල දිගු කාලසටහන් කාලසටහන් සහ CI නල මාර්ගවල දිගු ගොඩනැගීමේ වේලාවන් ඇතිවේ.
Безопасность: විශාල රූපවල අවදානම් සඳහා විශාල ප්‍රදේශයක් ද ඇත.

ඩොකර් රූපයක් සෑදී ඇත්තේ ස්තර තොගයකින් වන අතර, ඒ සෑම එකක්ම අපගේ Dockerfile හි ප්‍රකාශයක් නියෝජනය කරයි. සෑම ස්ථරයක්ම යටින් පවතින ස්ථරයේ වෙනස්කම්වල ඩෙල්ටා නියෝජනය කරයි. අපි Registry එකෙන් Docker image එකක් ඇදලා ගත්තම ඒක layers වලින් ඇදලා host එකේ cach කරනවා.

Spring Boot භාවිතා කරයි "මේද JAR" තුළ පෙරනිමි ඇසුරුම් ආකෘතිය ලෙස. අපි මහත JAR එකක් දෙස බලන විට, යෙදුම සමස්ත JAR හි ඉතා කුඩා කොටසක් බව අපට පෙනේ. මෙය වඩාත්ම වෙනස් වන කොටසයි. ඉතිරිය Spring Framework පරායත්තයන්ගෙන් සමන්විත වේ.

ප්‍රශස්තකරණ සූත්‍රය කේන්ද්‍රගත වී ඇත්තේ වසන්ත රාමු පරායත්තතාවලින් යෙදුම වෙනම මට්ටමකින් හුදකලා කිරීම වටා ය.

ඝන JAR ගොනුවේ වැඩි කොටසක් සාදන පරායත්ත ස්තරය එක් වරක් පමණක් බාගත කර ධාරක පද්ධතිය මත හැඹිලිගත වේ.

යෙදුම් යාවත්කාලීන සහ බහාලුම් උපලේඛනගත කිරීමේදී යෙදුමේ තුනී ස්ථරයක් පමණක් ඇද ගනු ලැබේ, මෙම රූප සටහනේ පෙන්වා ඇති පරිදි:

පහත කොටස් වලින්, අපි Spring Boot යෙදුමක් සඳහා මෙම ප්‍රශස්ත රූප නිර්මාණය කරන්නේ කෙසේදැයි බලමු.

Buildpack සමඟ Spring Boot යෙදුමක් සඳහා ප්‍රශස්ත බහාලුම් රූපයක් තැනීම

ස්ප්‍රිං බූට් 2.3 ඝන JAR ගොනුවක කොටස් වෙනම ස්ථරවලට උකහා ගැනීමෙන් ලේයර් කිරීම සඳහා සහය දක්වයි. ස්ථර කිරීමේ විශේෂාංගය පෙරනිමියෙන් අක්‍රිය කර ඇති අතර Spring Boot Maven ප්ලගිනය භාවිතයෙන් පැහැදිලිව සක්‍රිය කළ යුතුය:

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

අපි මෙම වින්‍යාසය භාවිතා කර අපගේ බහාලුම් රූපය පළමුව Buildpack සමඟින් සහ පසුව Docker සමඟ පහත කොටස් වලින් ගොඩනඟමු.

අපි දුවමු build-imageබහාලුම් රූපයක් නිර්මාණය කිරීමට Maven ඉලක්කය:

mvn spring-boot:build-image

ප්‍රතිඵලයක් ලෙස ලැබෙන රූපයේ ඇති ස්තර බැලීමට අපි ඩයිව් ධාවනය කළහොත්, ඝන JAR ආකෘතියෙන් අප ලබා ගත් දෙයට සාපේක්ෂව යෙදුම් ස්තරය (රතු පැහැයෙන් රවුම් කර ඇති) කිලෝබයිට් පරාසය තුළ ඉතා කුඩා බව අපට දැකගත හැකිය:

Docker සමඟ Spring Boot යෙදුමක් සඳහා ප්‍රශස්ත බහාලුම් රූපයක් තැනීම

Maven හෝ Gradle ප්ලගිනයක් භාවිතා කිරීම වෙනුවට, අපට Docker ගොනුවක් සමඟ ස්ථර ඩොකර් JAR රූපයක් නිර්මාණය කළ හැකිය.

අපි Docker භාවිතා කරන විට, ස්ථර නිස්සාරණය කර අවසාන රූපයට පිටපත් කිරීමට අමතර පියවර දෙකක් ගත යුතුය.

ස්ථර සක්‍රීය කර Maven සමඟ ගොඩනැගීමෙන් පසු ලැබෙන JAR හි අන්තර්ගතය මේ ආකාරයෙන් පෙනෙනු ඇත:

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

ප්‍රතිදානය නම් අතිරේක JAR එකක් පෙන්වයි spring-boot-jarmode-layertoolsи layersfle.idxගොනුව. මෙම අතිරේක JAR ගොනුව ඊළඟ කොටසේ විස්තර කර ඇති පරිදි ස්ථර කිරීමේ හැකියාවන් සපයයි.

වෙනම ස්ථර මත යැපීම් උපුටා ගන්න

අපගේ ස්ථර JAR වෙතින් ස්ථර බැලීම සහ උපුටා ගැනීම සඳහා, අපි පද්ධති ගුණාංගය භාවිතා කරමු -Djarmode=layertoolsආරම්භය සඳහා spring-boot-jarmode-layertoolsයෙදුම වෙනුවට JAR:

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

මෙම විධානය ක්‍රියාත්මක කිරීමෙන් පවතින විධාන විකල්ප අඩංගු ප්‍රතිදානයක් නිපදවයි:

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

ප්රතිදානය විධාන පෙන්වයි list, extractи helpс helpපෙරනිමිය වන්න. සමඟ විධානය ක්‍රියාත්මක කරමු listවිකල්පය:

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

dependencies
spring-boot-loader
snapshot-dependencies
application

ස්ථර ලෙස එකතු කළ හැකි පරායත්ත ලැයිස්තුවක් අපට පෙනේ.

පෙරනිමියෙන් ස්ථර:

ස්ථරයේ නම

අන්තර්ගතය

dependencies

SNAPSHOT අඩංගු නොවන අනුවාදයක ඕනෑම පරායත්තයක්

spring-boot-loader

JAR ලෝඩර් පන්ති

snapshot-dependencies

SNAPSHOT අඩංගු ඕනෑම පරායත්ත අනුවාදයක්

application

යෙදුම් පන්ති සහ සම්පත්

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

වෙනම ස්ථරවලට උපුටා ගත් පරායත්තතා සහිත රූපයක් ගොඩනැගීම

යන ක්‍රමය භාවිතා කර අපි අවසාන රූපය පියවර දෙකකින් ගොඩනඟමු බහු අදියර එකලස් කිරීම . පළමු පියවරේදී අපි පරායත්තයන් උපුටා ගන්නා අතර දෙවන පියවරේදී අපි උපුටා ගත් පරායත්තයන් අවසාන එකට පිටපත් කරමු.

බහු-අදියර ගොඩනැගීම සඳහා අපගේ Dockerfile වෙනස් කරමු:

# 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"]

අපි මෙම වින්‍යාසය වෙනම ගොනුවක සුරකිමු - Dockerfile2.

අපි විධානය භාවිතා කර ඩොකර් රූපය ගොඩනඟමු:

docker build -f Dockerfile2 -t usersignup:v1 .

මෙම විධානය ක්‍රියාත්මක කිරීමෙන් පසු, අපට පහත ප්‍රතිදානය ලැබේ:

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

අපිට පේනවා Docker image එක image ID එකකින් හදලා ඊට පස්සේ tag කරලා තියෙනවා.

අවසාන වශයෙන්, ජනනය කරන ලද ඩොකර් රූපයේ ඇති ස්ථර පරීක්ෂා කිරීමට අපි පෙර පරිදිම ඩයිව් විධානය ක්‍රියාත්මක කරමු. අපට ඩයිව් විධානයට ආදානය ලෙස රූප හැඳුනුම්පතක් හෝ ටැගයක් සැපයිය හැකිය:

dive userssignup:v1

ප්‍රතිදානයෙන් ඔබට පෙනෙන පරිදි, යෙදුම අඩංගු ස්තරය දැන් 11 KB පමණක් වන අතර පරායත්තතා වෙනම ස්ථර වල හැඹිලිගත කර ඇත.

වෙනම ස්ථර මත අභ්යන්තර පරායත්තයන් උපුටා ගන්න

අපගේ ඕනෑම අභිරුචි පරායත්තතා ප්‍රකාශ කිරීමෙන් යෙදුම සමඟ ඇසුරුම් කරනවා වෙනුවට වෙනම ස්ථරයකට උපුටා ගැනීමෙන් අපට යෙදුම් ස්ථරයේ ප්‍රමාණය තවදුරටත් අඩු කළ හැකිය. ymlසමාන ගොනුව නම් කර ඇත 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/"

මෙම ගොනුවේ layers.idxඅපි අභිරුචි පරායත්තතාවයක් එකතු කර ඇත, io.myorgහවුල් ගබඩාවෙන් ලබාගත් සංවිධාන පරායත්තතා අඩංගුය.

නිගමනය

මෙම ලිපියෙන්, අපි මූලාශ්‍රයෙන් සෘජුවම බහාලුම් රූපයක් තැනීමට Cloud-Native Buildpacks භාවිතා කිරීම දෙස බැලුවෙමු. මෙය සාමාන්‍ය ආකාරයෙන් බහාලුම් රූපයක් නිර්මාණය කිරීම සඳහා ඩොකර් භාවිතා කිරීම සඳහා විකල්පයකි: පළමුව, ඝන ක්‍රියාත්මක කළ හැකි JAR ගොනුවක් සාදනු ලබන අතර පසුව Dockerfile හි උපදෙස් සඳහන් කිරීමෙන් බහාලුම් රූපයකට ඇසුරුම් කරනු ලැබේ.

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

ලිපියේ භාවිතා කර ඇති සියලුම මූල කේතය ඔබට සොයාගත හැකිය Github .

විධාන යොමුව

ඉක්මන් යොමුවක් සඳහා අපි මෙම ලිපියේ භාවිතා කළ විධානවල සාරාංශයක් මෙන්න.

සන්දර්භය ඉවත් කිරීම:

docker system prune -a

Dockerfile සමඟ බහාලුම් රූපයක් තැනීම:

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

මූලාශ්‍රයෙන් බහාලුම් රූපයක් සාදන්න (Dockerfile නොමැතිව):

mvn spring-boot:build-image

පරායත්ත ස්ථර බලන්න. යෙදුම් jar ගොනුව තැනීමට පෙර, වසන්ත-boot-maven-plugin තුළ ස්ථර කිරීමේ විශේෂාංගය සක්‍රීය කර ඇති බවට වග බලා ගන්න:

java -Djarmode=layertools -jar application.jar list

පරායත්ත ස්ථර උපුටා ගන්න. යෙදුම් jar ගොනුව තැනීමට පෙර, වසන්ත-boot-maven-plugin තුළ ස්ථර කිරීමේ විශේෂාංගය සක්‍රීය කර ඇති බවට වග බලා ගන්න:

 java -Djarmode=layertools -jar application.jar extract

බහාලුම් පින්තූර ලැයිස්තුවක් බැලීම

docker images

බහාලුම් රූපය තුළ වම් පසින් බලන්න (කිමිදුම් මෙවලම ස්ථාපනය කර ඇති බවට වග බලා ගන්න):

dive <image ID or image tag>

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

Spring Boot යෙදුමක් සඳහා Optimized Docker Images ගොඩනැගීම