స్ప్రింగ్ బూట్ అప్లికేషన్ కోసం ఆప్టిమైజ్ చేసిన డాకర్ చిత్రాలను రూపొందించడం

అప్లికేషన్‌ను దాని అన్ని సాఫ్ట్‌వేర్ మరియు ఆపరేటింగ్ సిస్టమ్ డిపెండెన్సీలతో ప్యాకేజింగ్ చేయడానికి మరియు వాటిని వివిధ వాతావరణాలకు పంపిణీ చేయడానికి కంటైనర్‌లు ప్రాధాన్య మార్గంగా మారాయి.

ఈ కథనం స్ప్రింగ్ బూట్ అప్లికేషన్‌ను కంటెయినరైజ్ చేయడానికి వివిధ మార్గాలను వివరిస్తుంది:

• డాకర్ ఫైల్‌ని ఉపయోగించి డాకర్ చిత్రాన్ని సృష్టించడం,
• క్లౌడ్-నేటివ్ బిల్డ్‌ప్యాక్ ఉపయోగించి మూలం నుండి OCI చిత్రాన్ని సృష్టించడం,
• మరియు బహుళ-స్థాయి సాధనాలను ఉపయోగించి JAR యొక్క భాగాలను వేర్వేరు లేయర్‌లుగా విభజించడం ద్వారా రన్-టైమ్ ఇమేజ్ ఆప్టిమైజేషన్.

 కోడ్ ఉదాహరణ

ఈ కథనం వర్కింగ్ కోడ్ ఉదాహరణతో కూడి ఉంటుంది GitHubలో .

కంటైనర్ పరిభాష

మేము వ్యాసంలో ఉపయోగించిన కంటైనర్ పదజాలంతో ప్రారంభిస్తాము:

• కంటైనర్ చిత్రం: నిర్దిష్ట ఫార్మాట్ యొక్క ఫైల్. బిల్డ్ టూల్‌ని అమలు చేయడం ద్వారా మేము మా అప్లికేషన్‌ను కంటైనర్ ఇమేజ్‌గా మారుస్తాము.
• కంటైనర్: కంటైనర్ ఇమేజ్ యొక్క ఎక్జిక్యూటబుల్ ఇన్‌స్టాన్స్.
• కంటైనర్ ఇంజిన్: కంటైనర్‌ను అమలు చేయడానికి బాధ్యత వహించే డెమోన్ ప్రక్రియ.
• కంటైనర్ హోస్ట్: కంటైనర్ ఇంజిన్ రన్ అయ్యే హోస్ట్ కంప్యూటర్.
• కంటైనర్ రిజిస్ట్రీ: కంటైనర్ చిత్రాన్ని ప్రచురించడానికి మరియు పంపిణీ చేయడానికి ఉపయోగించే సాధారణ స్థానం.
• OCI ప్రమాణం: ఓపెన్ కంటైనర్ ఇనిషియేటివ్ (OCI) Linux ఫౌండేషన్‌లో ఏర్పడిన తేలికైన, ఓపెన్ గవర్నెన్స్ నిర్మాణం. OCI ఇమేజ్ స్పెసిఫికేషన్ కంటైనర్ ఇమేజ్ మరియు రన్‌టైమ్ ఫార్మాట్‌ల కోసం పరిశ్రమ ప్రమాణాలను నిర్వచిస్తుంది, అన్ని కంటైనర్ ఇంజిన్‌లు ఏదైనా బిల్డ్ టూల్ ద్వారా సృష్టించబడిన కంటైనర్ ఇమేజ్‌లను అమలు చేయగలవని నిర్ధారించడానికి.

అప్లికేషన్‌ను కంటెయినరైజ్ చేయడానికి, మేము మా అప్లికేషన్‌ను కంటైనర్ ఇమేజ్‌లో చుట్టి, ఆ చిత్రాన్ని షేర్ చేసిన రిజిస్ట్రీకి ప్రచురిస్తాము. కంటైనర్ రన్‌టైమ్ ఈ చిత్రాన్ని రిజిస్ట్రీ నుండి తిరిగి పొందుతుంది, దాన్ని అన్‌ప్యాక్ చేస్తుంది మరియు దాని లోపల అప్లికేషన్‌ను రన్ చేస్తుంది.

స్ప్రింగ్ బూట్ వెర్షన్ 2.3 OCI ఇమేజ్‌లను రూపొందించడానికి ప్లగిన్‌లను అందిస్తుంది.

డాకర్ అనేది సాధారణంగా ఉపయోగించే కంటైనర్ అమలు, మరియు మేము మా ఉదాహరణలలో డాకర్‌ని ఉపయోగిస్తాము, కాబట్టి ఈ కథనంలోని అన్ని తదుపరి కంటైనర్ రిఫరెన్స్‌లు డాకర్‌ని సూచిస్తాయి.

సాంప్రదాయ పద్ధతిలో కంటైనర్ చిత్రాన్ని నిర్మించడం

డాకర్ ఫైల్‌కి కొన్ని సూచనలను జోడించడం ద్వారా స్ప్రింగ్ బూట్ అప్లికేషన్‌ల కోసం డాకర్ ఇమేజ్‌లను సృష్టించడం చాలా సులభం.

మేము మొదట ఎక్జిక్యూటబుల్ JAR ఫైల్‌ను సృష్టిస్తాము మరియు డాకర్ ఫైల్ సూచనలలో భాగంగా, అవసరమైన సెట్టింగ్‌లను వర్తింపజేసిన తర్వాత బేస్ JRE ఇమేజ్ పైన ఎక్జిక్యూటబుల్ JAR ఫైల్‌ను కాపీ చేస్తాము.

మన స్ప్రింగ్ అప్లికేషన్‌ని క్రియేట్ చేద్దాం స్ప్రింగ్ ఇనిషియలైజర్ డిపెండెన్సీలతో web, lombokи actuator. మేము APIని అందించడానికి విశ్రాంతి నియంత్రికను కూడా జోడిస్తున్నాము GETపద్ధతి.

డాకర్‌ఫైల్‌ను సృష్టిస్తోంది

మేము జోడించడం ద్వారా ఈ అప్లికేషన్‌ను కంటైనర్‌గా మారుస్తాము Dockerfile:

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

మా డాకర్ ఫైల్‌లో బేస్ ఇమేజ్ ఉంది adoptopenjdk, దాని పైన మేము మా JAR ఫైల్‌ను కాపీ చేసి, ఆపై పోర్ట్‌ను తెరవండి, 8080ఇది అభ్యర్థనలను వింటుంది.

అప్లికేషన్ బిల్డింగ్

మొదట మీరు మావెన్ లేదా గ్రేడిల్ ఉపయోగించి అప్లికేషన్‌ను సృష్టించాలి. ఇక్కడ మేము మావెన్‌ని ఉపయోగిస్తాము:

mvn clean package

ఇది అప్లికేషన్ కోసం ఎక్జిక్యూటబుల్ JAR ఫైల్‌ను సృష్టిస్తుంది. డాకర్ ఇంజిన్‌లో అమలు చేయడానికి మేము ఈ ఎక్జిక్యూటబుల్ JARని డాకర్ ఇమేజ్‌గా మార్చాలి.

కంటైనర్ చిత్రాన్ని సృష్టిస్తోంది

మేము ఆదేశాన్ని అమలు చేయడం ద్వారా ఈ ఎక్జిక్యూటబుల్ JAR ఫైల్‌ను డాకర్ ఇమేజ్‌లో ఉంచాము docker buildముందుగా సృష్టించిన డాకర్‌ఫైల్‌ని కలిగి ఉన్న ప్రాజెక్ట్ రూట్ డైరెక్టరీ నుండి:

docker build  -t usersignup:v1 .

ఆదేశాన్ని ఉపయోగించి జాబితాలో మన చిత్రాన్ని చూడవచ్చు:

docker images 

పై ఆదేశం యొక్క అవుట్‌పుట్‌లో మా చిత్రం ఉంటుంది usersignupబేస్ ఇమేజ్‌తో పాటు, adoptopenjdkమా డాకర్ ఫైల్‌లో పేర్కొనబడింది.

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

కంటైనర్ చిత్రం లోపల లేయర్‌లను వీక్షించండి

చిత్రం లోపల పొరల స్టాక్‌ను చూద్దాం. మేము ఉపయోగిస్తాము సాధనం  డైవ్ ఈ పొరలను వీక్షించడానికి:

dive usersignup:v1

డైవ్ కమాండ్ నుండి అవుట్‌పుట్‌లో కొంత భాగం ఇక్కడ ఉంది: 

మనం చూడగలిగినట్లుగా, అప్లికేషన్ లేయర్ ఇమేజ్ పరిమాణంలో గణనీయమైన భాగాన్ని కలిగి ఉంటుంది. మేము మా ఆప్టిమైజేషన్‌లో భాగంగా క్రింది విభాగాలలో ఈ లేయర్ పరిమాణాన్ని తగ్గించాలనుకుంటున్నాము.

బిల్డ్‌ప్యాక్‌ని ఉపయోగించి కంటైనర్ చిత్రాన్ని సృష్టిస్తోంది

అసెంబ్లీ ప్యాకేజీలు (బిల్డ్‌ప్యాక్‌లు) అనేది సోర్స్ కోడ్ నుండి కంటైనర్ ఇమేజ్‌ని రూపొందించడానికి వివిధ ప్లాట్‌ఫారమ్‌లు సర్వీస్ (PAAS) ఆఫర్‌లుగా ఉపయోగించే సాధారణ పదం. ఇది 2011లో Heroku ద్వారా ప్రారంభించబడింది మరియు క్లౌడ్ ఫౌండ్రీ, Google App ఇంజిన్, Gitlab, Knative మరియు అనేక ఇతర వాటి ద్వారా స్వీకరించబడింది.

క్లౌడ్ బిల్డ్ ప్యాకేజీల ప్రయోజనం

చిత్రాలను రూపొందించడానికి బిల్డ్‌ప్యాక్‌ని ఉపయోగించడం వల్ల కలిగే ప్రధాన ప్రయోజనాల్లో ఒకటి ఇమేజ్ కాన్ఫిగరేషన్ మార్పులను కేంద్రంగా (బిల్డర్) నిర్వహించవచ్చు మరియు బిల్డర్‌ని ఉపయోగించి అన్ని అప్లికేషన్‌లకు ప్రచారం చేయవచ్చు.

బిల్డ్ ప్యాకేజీలు ప్లాట్‌ఫారమ్‌కు గట్టిగా జతచేయబడ్డాయి. క్లౌడ్-నేటివ్ బిల్డ్‌ప్యాక్‌లు OCI ఇమేజ్ ఫార్మాట్‌కు మద్దతు ఇవ్వడం ద్వారా ప్లాట్‌ఫారమ్‌ల అంతటా ప్రామాణీకరణను అందిస్తాయి, ఇది చిత్రాన్ని డాకర్ ఇంజిన్ ద్వారా అమలు చేయగలదని నిర్ధారిస్తుంది.

స్ప్రింగ్ బూట్ ప్లగ్ఇన్ ఉపయోగించడం

స్ప్రింగ్ బూట్ ప్లగ్ఇన్ బిల్డ్‌ప్యాక్ ఉపయోగించి మూలం నుండి OCI ఇమేజ్‌లను నిర్మిస్తుంది. ఉపయోగించి చిత్రాలు రూపొందించబడ్డాయి bootBuildImageపనులు (గ్రేడిల్) లేదా spring-boot:build-imageలక్ష్యాలు (మావెన్) మరియు స్థానిక డాకర్ ఇన్‌స్టాలేషన్.

పేరును పేర్కొనడం ద్వారా డాకర్ రిజిస్ట్రీకి నెట్టడానికి అవసరమైన చిత్రం పేరును మేము అనుకూలీకరించవచ్చు 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>

దీన్ని చేయడానికి మావెన్‌ని ఉపయోగించుకుందాం build-imageఅనువర్తనాన్ని సృష్టించడం మరియు కంటైనర్ చిత్రాన్ని రూపొందించడం కోసం లక్ష్యాలు. మేము ఈ సమయంలో ఏ డాకర్‌ఫైల్‌లను ఉపయోగించడం లేదు.

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>

తరువాత, అప్లికేషన్‌ను రూపొందించడానికి మరియు కంటైనర్ చిత్రాన్ని రూపొందించడానికి మేము మావెన్ కమాండ్‌ను ఉపయోగించి Jib ప్లగిన్‌ను అమలు చేస్తాము. మునుపటిలాగా, మేము ఇక్కడ ఏ డాకర్ ఫైల్‌లను ఉపయోగించడం లేదు:

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

పై మావెన్ ఆదేశాన్ని అమలు చేసిన తర్వాత, మనకు ఈ క్రింది అవుట్‌పుట్ వస్తుంది:

[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 పైప్‌లైన్‌లలో ఎక్కువ నిర్మాణ సమయాలు ఉంటాయి.
• భద్రత: పెద్ద చిత్రాలు కూడా దుర్బలత్వాల కోసం పెద్ద ప్రాంతాన్ని కలిగి ఉంటాయి.

ఒక డాకర్ చిత్రం లేయర్‌ల స్టాక్‌ను కలిగి ఉంటుంది, వీటిలో ప్రతి ఒక్కటి మా డాకర్‌ఫైల్‌లోని సూచనలను సూచిస్తుంది. ప్రతి పొర అంతర్లీన పొరలో మార్పుల డెల్టాను సూచిస్తుంది. మేము రిజిస్ట్రీ నుండి డాకర్ చిత్రాన్ని లాగినప్పుడు, అది లేయర్‌లలో లాగబడుతుంది మరియు హోస్ట్‌లో కాష్ చేయబడుతుంది.

స్ప్రింగ్ బూట్ ఉపయోగిస్తుంది "కొవ్వు JAR" లో డిఫాల్ట్ ప్యాకేజింగ్ ఫార్మాట్‌గా. మేము మందపాటి JARని చూసినప్పుడు, అప్లికేషన్ మొత్తం JARలో చాలా చిన్న భాగాన్ని కలిగి ఉందని మేము చూస్తాము. ఇది చాలా తరచుగా మారే భాగం. మిగిలినవి స్ప్రింగ్ ఫ్రేమ్‌వర్క్ డిపెండెన్సీలను కలిగి ఉంటాయి.

ఆప్టిమైజేషన్ ఫార్ములా స్ప్రింగ్ ఫ్రేమ్‌వర్క్ డిపెండెన్సీల నుండి ప్రత్యేక స్థాయిలో అప్లికేషన్‌ను వేరుచేయడం చుట్టూ కేంద్రీకరిస్తుంది.

మందపాటి JAR ఫైల్‌లో ఎక్కువ భాగాన్ని రూపొందించే డిపెండెన్సీ లేయర్ ఒక్కసారి మాత్రమే డౌన్‌లోడ్ చేయబడుతుంది మరియు హోస్ట్ సిస్టమ్‌లో కాష్ చేయబడుతుంది.

అప్లికేషన్ అప్‌డేట్‌లు మరియు కంటైనర్ షెడ్యూలింగ్ సమయంలో అప్లికేషన్ యొక్క పలుచని పొర మాత్రమే లాగబడుతుంది. ఈ రేఖాచిత్రంలో చూపిన విధంగా:

క్రింది విభాగాలలో, స్ప్రింగ్ బూట్ అప్లికేషన్ కోసం ఈ ఆప్టిమైజ్ చేసిన చిత్రాలను ఎలా సృష్టించాలో చూద్దాం.

బిల్డ్‌ప్యాక్ ఉపయోగించి స్ప్రింగ్ బూట్ అప్లికేషన్ కోసం ఆప్టిమైజ్ చేసిన కంటైనర్ ఇమేజ్‌ను సృష్టిస్తోంది

స్ప్రింగ్ బూట్ 2.3 మందపాటి JAR ఫైల్ యొక్క భాగాలను ప్రత్యేక లేయర్‌లలోకి సంగ్రహించడం ద్వారా లేయరింగ్‌కు మద్దతు ఇస్తుంది. లేయరింగ్ ఫీచర్ డిఫాల్ట్‌గా నిలిపివేయబడింది మరియు స్ప్రింగ్ బూట్ మావెన్ ప్లగ్ఇన్‌ని ఉపయోగించి స్పష్టంగా ప్రారంభించబడాలి:

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

మేము ఈ కాన్ఫిగరేషన్‌ని ముందుగా బిల్డ్‌ప్యాక్‌తో మరియు తరువాత క్రింది విభాగాలలో డాకర్‌తో మా కంటైనర్ చిత్రాన్ని రూపొందించడానికి ఉపయోగిస్తాము.

లాంచ్ చేద్దాం build-imageకంటైనర్ చిత్రాన్ని రూపొందించడానికి మావెన్ లక్ష్యం:

mvn spring-boot:build-image

మేము ఫలిత చిత్రంలో లేయర్‌లను చూడటానికి డైవ్‌ని అమలు చేస్తే, మేము కొవ్వు JAR ఆకృతిని ఉపయోగించి పొందిన దానితో పోలిస్తే కిలోబైట్ పరిధిలో అప్లికేషన్ లేయర్ (ఎరుపు రంగులో వివరించబడింది) చాలా తక్కువగా ఉన్నట్లు మనం చూడవచ్చు:

డాకర్‌ని ఉపయోగించి స్ప్రింగ్ బూట్ అప్లికేషన్ కోసం ఆప్టిమైజ్ చేసిన కంటైనర్ ఇమేజ్‌ను సృష్టిస్తోంది

Maven లేదా Gradle ప్లగ్ఇన్‌ని ఉపయోగించకుండా, మేము డాకర్ ఫైల్‌తో లేయర్డ్ డాకర్ JAR చిత్రాన్ని కూడా సృష్టించవచ్చు.

మేము డాకర్‌ని ఉపయోగించినప్పుడు, లేయర్‌లను సంగ్రహించడానికి మరియు వాటిని తుది ఇమేజ్‌కి కాపీ చేయడానికి మేము రెండు అదనపు దశలను చేయాలి.

లేయరింగ్ ఎనేబుల్ చేయబడిన మావెన్‌ని ఉపయోగించి నిర్మించిన తర్వాత ఫలితంగా వచ్చే 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వాటిని డాకర్ ఇమేజ్‌కి జోడించాల్సిన క్రమంలో ఫైల్. ఈ లేయర్‌లు మొదటి పునరుద్ధరణ తర్వాత హోస్ట్‌లో కాష్ చేయబడతాయి ఎందుకంటే అవి మారవు. నవీకరించబడిన అప్లికేషన్ లేయర్ మాత్రమే హోస్ట్‌కి డౌన్‌లోడ్ చేయబడుతుంది, ఇది పరిమాణం తగ్గినందున వేగంగా ఉంటుంది .

ప్రత్యేక లేయర్‌లలోకి సంగ్రహించబడిన డిపెండెన్సీలతో చిత్రాన్ని రూపొందించడం

అనే పద్ధతిని ఉపయోగించి మేము చివరి చిత్రాన్ని రెండు దశల్లో నిర్మిస్తాము బహుళ-దశల అసెంబ్లీ . మొదటి దశలో మేము డిపెండెన్సీలను సంగ్రహిస్తాము మరియు రెండవ దశలో మేము సంగ్రహించిన డిపెండెన్సీలను తుది చిత్రంలోకి కాపీ చేస్తాము.

బహుళ-దశల నిర్మాణం కోసం మా డాకర్‌ఫైల్‌ను సవరించుదాం:

# 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

డాకర్ ఇమేజ్ ఇమేజ్ ఐడితో సృష్టించబడి, ఆపై ట్యాగ్ చేయబడిందని మనం చూడవచ్చు.

చివరగా, మేము రూపొందించిన డాకర్ ఇమేజ్‌లోని లేయర్‌లను తనిఖీ చేయడానికి మునుపటిలా డైవ్ ఆదేశాన్ని అమలు చేస్తాము. మేము డైవ్ కమాండ్‌కు ఇన్‌పుట్‌గా ఇమేజ్ ID లేదా ట్యాగ్‌ని అందించవచ్చు:

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షేర్డ్ రిపోజిటరీ నుండి తిరిగి పొందిన సంస్థ డిపెండెన్సీలను కలిగి ఉంటుంది.

తీర్మానం

ఈ కథనంలో, మేము నేరుగా సోర్స్ కోడ్ నుండి కంటైనర్ చిత్రాన్ని రూపొందించడానికి క్లౌడ్-నేటివ్ బిల్డ్‌ప్యాక్‌లను ఉపయోగించడాన్ని పరిశీలించాము. కంటైనర్ ఇమేజ్‌ని సాధారణ పద్ధతిలో సృష్టించడానికి డాకర్‌ని ఉపయోగించడం కోసం ఇది ప్రత్యామ్నాయం: ముందుగా మందపాటి ఎక్జిక్యూటబుల్ JAR ఫైల్‌ను సృష్టించి, ఆపై డాకర్ ఫైల్‌లో సూచనలను పేర్కొనడం ద్వారా కంటైనర్ ఇమేజ్‌లో ప్యాక్ చేయడం.

మేము హోస్ట్‌లో కాష్ చేయబడిన ప్రత్యేక లేయర్‌లలోకి డిపెండెన్సీలను లాగడం మరియు కంటైనర్ యొక్క ఎగ్జిక్యూషన్ ఇంజిన్‌లలో షెడ్యూల్ చేసే సమయంలో అప్లికేషన్ యొక్క పలుచని లేయర్ లోడ్ అయ్యే లేయరింగ్ ఫీచర్‌ని ఎనేబుల్ చేయడం ద్వారా మా కంటైనర్‌ను ఆప్టిమైజ్ చేయడం కూడా చూసాము.

వ్యాసంలో ఉపయోగించిన మొత్తం సోర్స్ కోడ్‌ను మీరు ఇక్కడ కనుగొనవచ్చు Github .

కమాండ్ సూచన

మేము ఈ కథనంలో ఉపయోగించిన ఆదేశాల యొక్క శీఘ్ర తగ్గింపు ఇక్కడ ఉంది.

సందర్భం క్లియరింగ్:

docker system prune -a

డాకర్ ఫైల్‌ని ఉపయోగించి కంటైనర్ చిత్రాన్ని సృష్టించడం:

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

మేము కంటైనర్ చిత్రాన్ని సోర్స్ కోడ్ నుండి (డాకర్‌ఫైల్ లేకుండా) నిర్మిస్తాము:

mvn spring-boot:build-image

డిపెండెన్సీ లేయర్‌లను వీక్షించండి. అప్లికేషన్ JAR ఫైల్‌ను రూపొందించడానికి ముందు, స్ప్రింగ్-బూట్-మావెన్-ప్లగ్ఇన్‌లో లేయరింగ్ ఫీచర్ ప్రారంభించబడిందని నిర్ధారించుకోండి:

java -Djarmode=layertools -jar application.jar list

డిపెండెన్సీ లేయర్‌లను సంగ్రహించడం. అప్లికేషన్ JAR ఫైల్‌ను రూపొందించడానికి ముందు, స్ప్రింగ్-బూట్-మావెన్-ప్లగ్ఇన్‌లో లేయరింగ్ ఫీచర్ ప్రారంభించబడిందని నిర్ధారించుకోండి:

 java -Djarmode=layertools -jar application.jar extract

కంటైనర్ చిత్రాల జాబితాను వీక్షించండి

docker images

కంటైనర్ ఇమేజ్ లోపల ఎడమవైపు వీక్షించండి (డైవ్ టూల్ ఇన్‌స్టాల్ చేయబడిందని నిర్ధారించుకోండి):

dive <image ID or image tag>

మూలం: www.habr.com