ஸ்பிரிங் பூட் பயன்பாட்டிற்கான உகந்த டோக்கர் படங்களை உருவாக்குதல்

கன்டெய்னர்கள் ஒரு பயன்பாட்டை அதன் அனைத்து மென்பொருள் மற்றும் இயக்க முறைமை சார்புகளுடன் பேக்கேஜிங் செய்வதற்கும் பின்னர் அவற்றை வெவ்வேறு சூழல்களுக்கு வழங்குவதற்கும் விருப்பமான வழிமுறையாக மாறிவிட்டன.

இந்த கட்டுரை ஸ்பிரிங் பூட் பயன்பாட்டைக் கண்டெய்னரைஸ் செய்வதற்கான பல்வேறு வழிகளை உள்ளடக்கியது:

• டாக்கர்ஃபைலைப் பயன்படுத்தி டாக்கர் படத்தை உருவாக்குதல்,
• Cloud-Native Buildpack ஐப் பயன்படுத்தி மூலத்திலிருந்து OCI படத்தை உருவாக்குதல்,
• மற்றும் அடுக்குக் கருவிகளைப் பயன்படுத்தி JAR பகுதிகளை வெவ்வேறு நிலைகளாகப் பிரிப்பதன் மூலம் இயக்க நேரத்தில் படத்தை மேம்படுத்துதல்.

 குறியீடு உதாரணம்

இந்த கட்டுரை வேலை செய்யும் குறியீட்டு உதாரணத்துடன் உள்ளது GitHub இல் .

கொள்கலன் சொற்கள்

கட்டுரை முழுவதும் பயன்படுத்தப்படும் கொள்கலன் சொற்களுடன் தொடங்குவோம்:

• கொள்கலன் படம்: ஒரு குறிப்பிட்ட வடிவத்தின் கோப்பு. உருவாக்க கருவியை இயக்குவதன் மூலம் எங்கள் பயன்பாட்டை ஒரு கொள்கலன் படமாக மாற்றுகிறோம்.
• கொள்கலன்: கொள்கலன் படத்தின் இயங்கக்கூடிய நிகழ்வு.
• கொள்கலன் இயந்திரம்: கொள்கலனை இயக்குவதற்கு டீமான் செயல்முறை பொறுப்பு.
• கொள்கலன் ஹோஸ்ட்: கொள்கலன் இயந்திரம் இயங்கும் ஹோஸ்ட் இயந்திரம்.
• கொள்கலன் பதிவு: கொள்கலன் படத்தை வெளியிடவும் விநியோகிக்கவும் பயன்படுத்தப்படும் பொதுவான இடம்.
• OCI தரநிலை: திறந்த கொள்கலன் முன்முயற்சி (OCI) லினக்ஸ் அறக்கட்டளையால் உருவாக்கப்பட்ட ஒரு இலகுரக, திறந்த மூல மேலாண்மை கட்டமைப்பாகும். OCI பட விவரக்குறிப்பு, கொள்கலன் பட வடிவங்களுக்கான தொழில் தரநிலைகளை வரையறுக்கிறது மற்றும் அனைத்து கன்டெய்னர் என்ஜின்களும் எந்த உருவாக்க கருவியாலும் உருவாக்கப்பட்ட கொள்கலன் படங்களை இயக்க முடியும் என்பதை உறுதிசெய்யும்.

ஒரு பயன்பாட்டைக் கொள்கலன் செய்ய, நாங்கள் எங்கள் விண்ணப்பத்தை ஒரு கொள்கலன் படத்தில் மூடி, அந்தப் படத்தைப் பொதுப் பதிவேட்டில் வெளியிடுகிறோம். கொள்கலன் இயக்க நேரம் இந்த படத்தை பதிவேட்டில் இருந்து மீட்டெடுக்கிறது, அதைத் திறக்கிறது மற்றும் அதன் உள்ளே பயன்பாட்டை இயக்குகிறது.

ஸ்பிரிங் பூட்டின் பதிப்பு 2.3 OCI படங்களை உருவாக்குவதற்கான செருகுநிரல்களை வழங்குகிறது.

கூலியாள் மிகவும் பொதுவாகப் பயன்படுத்தப்படும் கொள்கலன் செயலாக்கமாகும், மேலும் எங்கள் எடுத்துக்காட்டுகளில் டோக்கரைப் பயன்படுத்துகிறோம், எனவே இந்தக் கட்டுரையில் உள்ள அனைத்து அடுத்தடுத்த கொள்கலன் குறிப்புகளும் டோக்கரைக் குறிக்கும்.

பாரம்பரிய வழியில் ஒரு கொள்கலன் படத்தை உருவாக்குதல்

உங்கள் Dockerfile இல் சில வழிமுறைகளைச் சேர்ப்பதன் மூலம் Spring Boot பயன்பாடுகளுக்கான Docker படங்களை உருவாக்குவது மிகவும் எளிதானது.

நாங்கள் முதலில் இயங்கக்கூடிய JAR ஐ உருவாக்கி, Dockerfile வழிமுறைகளின் ஒரு பகுதியாக, தேவையான தனிப்பயனாக்கங்களைப் பயன்படுத்திய பிறகு, அடிப்படை 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"]

எங்கள் Dockerfile ஒரு அடிப்படைப் படத்தைக் கொண்டுள்ளது adoptopenjdk, அதன் மேல் நாங்கள் எங்கள் JAR கோப்பை நகலெடுத்து, பின்னர் போர்ட்டைத் திறக்கிறோம், 8080கோரிக்கைகளை கேட்கும்.

விண்ணப்ப சட்டசபை

முதலில் நீங்கள் Maven அல்லது Gradle ஐப் பயன்படுத்தி ஒரு பயன்பாட்டை உருவாக்க வேண்டும். இங்கே நாம் Maven ஐப் பயன்படுத்துகிறோம்:

mvn clean package

இது பயன்பாட்டிற்காக இயங்கக்கூடிய JAR கோப்பை உருவாக்குகிறது. இந்த எக்ஸிகியூட்டபிள் JARஐ டோக்கர் இன்ஜினில் இயக்க, டோக்கர் படமாக மாற்ற வேண்டும்.

ஒரு கொள்கலன் படத்தை உருவாக்கவும்

கட்டளையை இயக்குவதன் மூலம் இந்த JAR இயங்கக்கூடியதை டோக்கர் படத்தில் வைக்கிறோம் docker buildமுன்பு உருவாக்கப்பட்ட டாக்கர்ஃபைலைக் கொண்ட திட்டத்தின் மூல கோப்பகத்திலிருந்து:

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 மற்றும் சிலவற்றால் ஏற்றுக்கொள்ளப்பட்டது.

கிளவுட் பில்ட் தொகுப்புகளின் நன்மை

படங்களை உருவாக்க Buildpack ஐப் பயன்படுத்துவதன் முக்கிய நன்மைகளில் ஒன்று பட கட்டமைப்பு மாற்றங்களை மையமாக (பில்டர்) நிர்வகிக்கலாம் மற்றும் பில்டரைப் பயன்படுத்தி அனைத்து பயன்பாடுகளுக்கும் பரப்பலாம்.

கட்டுமானப் பொதிகள் மேடையில் நெருக்கமாக இணைக்கப்பட்டன. Cloud-Native Buildpacks ஆனது OCI பட வடிவமைப்பை ஆதரிப்பதன் மூலம் தளங்களில் தரப்படுத்தலை வழங்குகிறது, இது படத்தை Docker இன்ஜின் மூலம் இயக்க முடியும் என்பதை உறுதி செய்கிறது.

ஸ்பிரிங் பூட் செருகுநிரலைப் பயன்படுத்துதல்

ஸ்பிரிங் பூட் செருகுநிரல் பில்ட்பேக்கைப் பயன்படுத்தி மூலத்திலிருந்து OCI படங்களை உருவாக்குகிறது. பயன்படுத்தி படங்கள் உருவாக்கப்படுகின்றன bootBuildImageபணிகள் (Gradle) அல்லது 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-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 பைப்லைன்களில் நீண்ட கால உருவாக்க நேரங்களையும் விளைவிக்கிறது.
• பாதுகாப்பு: பெரிய படங்கள் பாதிப்புகளுக்கான பெரிய பகுதியையும் கொண்டுள்ளன.

ஒரு டோக்கர் படம் அடுக்குகளின் அடுக்கால் ஆனது, ஒவ்வொன்றும் எங்கள் Dockerfile இல் உள்ள ஒரு அறிக்கையைக் குறிக்கும். ஒவ்வொரு அடுக்கும் அடிப்படை அடுக்கில் உள்ள மாற்றங்களின் டெல்டாவைக் குறிக்கிறது. பதிவேட்டில் இருந்து ஒரு டோக்கர் படத்தை இழுக்கும்போது, ​​அது அடுக்குகளாக இழுக்கப்பட்டு ஹோஸ்டில் தற்காலிகமாக சேமிக்கப்படும்.

ஸ்பிரிங் பூட் பயன்படுத்துகிறது "கொழுப்பு JAR" இல் இயல்புநிலை பேக்கேஜிங் வடிவமாக. நாம் ஒரு கொழுத்த JAR ஐப் பார்க்கும்போது, ​​பயன்பாடு முழு JAR இன் மிகச் சிறிய பகுதியாக இருப்பதைக் காண்கிறோம். இது மிகவும் மாறக்கூடிய பகுதியாகும். மீதமுள்ளவை ஸ்பிரிங் ஃப்ரேம்வொர்க் சார்புகளைக் கொண்டுள்ளது.

உகப்பாக்கம் சூத்திரமானது, ஸ்பிரிங் ஃபிரேம்வொர்க் சார்புகளிலிருந்து ஒரு தனி மட்டத்தில் பயன்பாட்டைத் தனிமைப்படுத்துவதை மையமாகக் கொண்டது.

தடிமனான JAR கோப்பின் பெரும்பகுதியை உருவாக்கும் சார்பு அடுக்கு ஒரு முறை மட்டுமே பதிவிறக்கம் செய்யப்பட்டு ஹோஸ்ட் சிஸ்டத்தில் தற்காலிகமாக சேமிக்கப்படும்.

ஆப்ஸ் புதுப்பிப்புகள் மற்றும் கொள்கலன் திட்டமிடலின் போது பயன்பாட்டின் மெல்லிய அடுக்கு மட்டுமே இழுக்கப்படும், இந்த வரைபடத்தில் காட்டப்பட்டுள்ளபடி:

பின்வரும் பிரிவுகளில், ஸ்பிரிங் பூட் பயன்பாட்டிற்கான இந்த உகந்த படங்களை எவ்வாறு உருவாக்குவது என்று பார்ப்போம்.

Buildpack உடன் ஸ்பிரிங் பூட் பயன்பாட்டிற்கான உகந்த கொள்கலன் படத்தை உருவாக்குதல்

ஸ்பிரிங் பூட் 2.3 தடிமனான JAR கோப்பின் பகுதிகளை தனி அடுக்குகளாக பிரித்தெடுப்பதன் மூலம் அடுக்குகளை ஆதரிக்கிறது. லேயரிங் அம்சம் இயல்பாகவே முடக்கப்பட்டுள்ளது மற்றும் ஸ்பிரிங் பூட் மேவன் செருகுநிரலைப் பயன்படுத்தி வெளிப்படையாக இயக்கப்பட வேண்டும்:

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

பின்வரும் பிரிவுகளில் முதலில் Buildpack மற்றும் பின்னர் Docker உடன் எங்கள் கொள்கலன் படத்தை உருவாக்க இந்த உள்ளமைவைப் பயன்படுத்துவோம்.

ஓடுவோம் build-imageஒரு கொள்கலன் படத்தை உருவாக்க மேவன் இலக்கு:

mvn spring-boot:build-image

இதன் விளைவாக வரும் படத்தில் உள்ள லேயர்களைக் காண டைவ் இயக்கினால், தடிமனான 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

ஸ்னாப்ஷாட் இல்லாத எந்த சார்பு

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

டோக்கர் படம் ஒரு பட ஐடியுடன் உருவாக்கப்பட்டு பின்னர் குறியிடப்பட்டிருப்பதைக் காணலாம்.

இறுதியாக, உருவாக்கப்பட்ட டோக்கர் படத்துக்குள் உள்ள அடுக்குகளைப் பார்க்க, முன்பு போலவே டைவ் கட்டளையை இயக்குகிறோம். டைவ் கட்டளைக்கு ஒரு பட ஐடி அல்லது குறிச்சொல்லை உள்ளீடாக வழங்கலாம்:

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 கோப்பு உருவாக்கப்பட்டு, பின்னர் Dockerfile இல் உள்ள வழிமுறைகளைக் குறிப்பிடுவதன் மூலம் ஒரு கொள்கலன் படத்தில் தொகுக்கப்படுகிறது.

ஹோஸ்டில் தேக்ககப்படுத்தப்பட்ட தனித்தனி அடுக்குகளாக சார்புகளை பிரித்தெடுக்கும் லேயரிங் அம்சத்தைச் சேர்ப்பதன் மூலம் எங்கள் கொள்கலனை மேம்படுத்துவதையும் பார்த்தோம்.

கட்டுரையில் பயன்படுத்தப்பட்ட அனைத்து மூலக் குறியீட்டையும் நீங்கள் காணலாம் கிட்ஹப் .

கட்டளை குறிப்பு

விரைவான குறிப்புக்காக இந்த கட்டுரையில் நாங்கள் பயன்படுத்திய கட்டளைகளின் சுருக்கம் இங்கே.

சூழல் தெளிவு:

docker system prune -a

Dockerfile மூலம் ஒரு கொள்கலன் படத்தை உருவாக்குதல்:

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

மூலத்திலிருந்து கொள்கலன் படத்தை உருவாக்கவும் (Dockerfile இல்லாமல்):

mvn spring-boot:build-image

சார்பு அடுக்குகளைக் காண்க. பயன்பாட்டு ஜார் கோப்பை உருவாக்குவதற்கு முன், ஸ்பிரிங்-பூட்-மேவன்-பிளகினில் லேயரிங் அம்சம் இயக்கப்பட்டிருப்பதை உறுதிசெய்யவும்:

java -Djarmode=layertools -jar application.jar list

சார்பு அடுக்குகளை பிரித்தெடுக்கவும். பயன்பாட்டு ஜார் கோப்பை உருவாக்குவதற்கு முன், ஸ்பிரிங்-பூட்-மேவன்-பிளகினில் லேயரிங் அம்சம் இயக்கப்பட்டிருப்பதை உறுதிசெய்யவும்:

 java -Djarmode=layertools -jar application.jar extract

கொள்கலன் படங்களின் பட்டியலைப் பார்க்கிறது

docker images

கொள்கலன் படத்தின் உள்ளே இடதுபுறத்தில் காண்க (டைவ் கருவி நிறுவப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும்):

dive <image ID or image tag>

ஆதாரம்: www.habr.com