ಸ್ಪ್ರಿಂಗ್ ಬೂಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಆಪ್ಟಿಮೈಸ್ಡ್ ಡಾಕರ್ ಚಿತ್ರಗಳನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ

ಕಂಟೈನರ್‌ಗಳು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಅದರ ಎಲ್ಲಾ ಸಾಫ್ಟ್‌ವೇರ್ ಮತ್ತು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಅವಲಂಬನೆಗಳೊಂದಿಗೆ ಪ್ಯಾಕೇಜಿಂಗ್ ಮಾಡಲು ಮತ್ತು ನಂತರ ಅವುಗಳನ್ನು ವಿವಿಧ ಪರಿಸರಗಳಿಗೆ ತಲುಪಿಸಲು ಆದ್ಯತೆಯ ಸಾಧನವಾಗಿದೆ.

ಈ ಲೇಖನವು ಸ್ಪ್ರಿಂಗ್ ಬೂಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕಂಟೈನರೈಸ್ ಮಾಡಲು ವಿವಿಧ ವಿಧಾನಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:

• ಡಾಕರ್ ಫೈಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಡಾಕರ್ ಚಿತ್ರವನ್ನು ರಚಿಸುವುದು,
• ಕ್ಲೌಡ್-ನೇಟಿವ್ ಬಿಲ್ಡ್‌ಪ್ಯಾಕ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಮೂಲದಿಂದ OCI ಚಿತ್ರವನ್ನು ರಚಿಸುವುದು,
• ಮತ್ತು ಬಹು-ಶ್ರೇಣಿಯ ಉಪಕರಣಗಳನ್ನು ಬಳಸಿಕೊಂಡು JAR ನ ಭಾಗಗಳನ್ನು ವಿವಿಧ ಪದರಗಳಾಗಿ ಬೇರ್ಪಡಿಸುವ ಮೂಲಕ ರನ್-ಟೈಮ್ ಇಮೇಜ್ ಆಪ್ಟಿಮೈಸೇಶನ್.

 ಉದಾಹರಣೆ ಕೋಡ್

ಈ ಲೇಖನವು ಕೆಲಸದ ಕೋಡ್ ಉದಾಹರಣೆಯೊಂದಿಗೆ ಇರುತ್ತದೆ GitHub ನಲ್ಲಿ .

ಕಂಟೈನರ್ ಪರಿಭಾಷೆ

ಲೇಖನದಲ್ಲಿ ಬಳಸಲಾದ ಕಂಟೇನರ್ ಪರಿಭಾಷೆಯೊಂದಿಗೆ ನಾವು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ:

• ಕಂಟೇನರ್ ಚಿತ್ರ: ನಿರ್ದಿಷ್ಟ ಸ್ವರೂಪದ ಫೈಲ್. ಬಿಲ್ಡ್ ಟೂಲ್ ಅನ್ನು ರನ್ ಮಾಡುವ ಮೂಲಕ ನಾವು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕಂಟೇನರ್ ಇಮೇಜ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತೇವೆ.
• ಕಂಟೇನರ್: ಧಾರಕ ಚಿತ್ರದ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ನಿದರ್ಶನ.
• ಕಂಟೈನರ್ ಎಂಜಿನ್: ಧಾರಕವನ್ನು ಚಲಾಯಿಸಲು ಡೀಮನ್ ಪ್ರಕ್ರಿಯೆಯು ಕಾರಣವಾಗಿದೆ.
• ಕಂಟೈನರ್ ಹೋಸ್ಟ್: ಕಂಟೇನರ್ ಎಂಜಿನ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಹೋಸ್ಟ್ ಕಂಪ್ಯೂಟರ್.
• ಕಂಟೈನರ್ ನೋಂದಾವಣೆ: ಕಂಟೇನರ್ ಚಿತ್ರವನ್ನು ಪ್ರಕಟಿಸಲು ಮತ್ತು ವಿತರಿಸಲು ಬಳಸುವ ಸಾಮಾನ್ಯ ಸ್ಥಳ.
• OCI ಮಾನದಂಡ: ಓಪನ್ ಕಂಟೈನರ್ ಇನಿಶಿಯೇಟಿವ್ (OCI) ಲಿನಕ್ಸ್ ಫೌಂಡೇಶನ್‌ನಲ್ಲಿ ರೂಪುಗೊಂಡ ಹಗುರವಾದ, ಮುಕ್ತ ಆಡಳಿತ ರಚನೆಯಾಗಿದೆ. 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

ಜಿಬ್ ಬಳಸಿ ಕಂಟೇನರ್ ಚಿತ್ರವನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ

ಜಿಬ್ ಎಂಬುದು Google ನಿಂದ ಇಮೇಜ್ ರಚನೆಯ ಪ್ಲಗಿನ್ ಆಗಿದ್ದು ಅದು ಮೂಲ ಕೋಡ್‌ನಿಂದ ಕಂಟೇನರ್ ಚಿತ್ರವನ್ನು ರಚಿಸಲು ಪರ್ಯಾಯ ವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗುತ್ತಿದೆ jib-maven-pluginpom.xml ನಲ್ಲಿ:

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

ಮುಂದೆ, ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ಕಂಟೇನರ್ ಚಿತ್ರವನ್ನು ರಚಿಸಲು ನಾವು ಮಾವೆನ್ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಜಿಬ್ ಪ್ಲಗಿನ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತೇವೆ. ಮೊದಲಿನಂತೆ, ನಾವು ಇಲ್ಲಿ ಯಾವುದೇ ಡಾಕರ್ ಫೈಲ್‌ಗಳನ್ನು ಬಳಸುತ್ತಿಲ್ಲ:

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

ಡಾಕರ್ ಇಮೇಜ್ ಅನ್ನು ಇಮೇಜ್ ಐಡಿಯೊಂದಿಗೆ ರಚಿಸಲಾಗಿದೆ ಮತ್ತು ನಂತರ ಟ್ಯಾಗ್ ಮಾಡಿರುವುದನ್ನು ನಾವು ನೋಡಬಹುದು.

ಅಂತಿಮವಾಗಿ, ರಚಿಸಿದ ಡಾಕರ್ ಚಿತ್ರದೊಳಗಿನ ಪದರಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ನಾವು ಮೊದಲಿನಂತೆ ಡೈವ್ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುತ್ತೇವೆ. ಡೈವ್ ಕಮಾಂಡ್‌ಗೆ ಇನ್‌ಪುಟ್ ಆಗಿ ನಾವು ಇಮೇಜ್ ಐಡಿ ಅಥವಾ ಟ್ಯಾಗ್ ಅನ್ನು ಒದಗಿಸಬಹುದು:

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