ഒരു സ്പ്രിംഗ് ബൂട്ട് ആപ്ലിക്കേഷനായി ഒപ്റ്റിമൈസ് ചെയ്ത ഡോക്കർ ഇമേജുകൾ നിർമ്മിക്കുന്നു

ഒരു ആപ്ലിക്കേഷനെ അതിന്റെ എല്ലാ സോഫ്റ്റ്‌വെയർ, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഡിപൻഡൻസികൾ എന്നിവ ഉപയോഗിച്ച് പാക്കേജ് ചെയ്യുന്നതിനും പിന്നീട് അവയെ വ്യത്യസ്ത പരിതസ്ഥിതികളിലേക്ക് എത്തിക്കുന്നതിനും കണ്ടെയ്‌നറുകൾ തിരഞ്ഞെടുക്കപ്പെട്ട മാർഗമായി മാറിയിരിക്കുന്നു.

ഒരു സ്പ്രിംഗ് ബൂട്ട് ആപ്ലിക്കേഷൻ കണ്ടെയ്നറൈസ് ചെയ്യുന്നതിനുള്ള വ്യത്യസ്ത വഴികൾ ഈ ലേഖനം ഉൾക്കൊള്ളുന്നു:

• ഒരു ഡോക്കർ ഫയൽ ഉപയോഗിച്ച് ഒരു ഡോക്കർ ഇമേജ് സൃഷ്ടിക്കുന്നു,
• Cloud-Native Buildpack ഉപയോഗിച്ച് ഉറവിടത്തിൽ നിന്ന് ഒരു OCI ഇമേജ് സൃഷ്ടിക്കുന്നു,
• കൂടാതെ മൾട്ടി-ടയർ ടൂളുകൾ ഉപയോഗിച്ച് JAR-ന്റെ ഭാഗങ്ങൾ വ്യത്യസ്ത ലെയറുകളായി വേർതിരിച്ചുകൊണ്ട് റൺ-ടൈം ഇമേജ് ഒപ്റ്റിമൈസേഷൻ.

 കോഡ് ഉദാഹരണം

ഈ ലേഖനം വർക്കിംഗ് കോഡ് ഉദാഹരണത്തോടൊപ്പമുണ്ട് GitHub-ൽ .

കണ്ടെയ്നർ ടെർമിനോളജി

ലേഖനത്തിൽ ഉപയോഗിച്ചിരിക്കുന്ന കണ്ടെയ്നർ ടെർമിനോളജിയിൽ നിന്ന് ഞങ്ങൾ ആരംഭിക്കും:

• കണ്ടെയ്നർ ചിത്രം: ഒരു പ്രത്യേക ഫോർമാറ്റിന്റെ ഫയൽ. ബിൽഡ് ടൂൾ പ്രവർത്തിപ്പിച്ച് ഞങ്ങൾ ഞങ്ങളുടെ ആപ്ലിക്കേഷനെ ഒരു കണ്ടെയ്‌നർ ഇമേജാക്കി മാറ്റും.
• കണ്ടെയ്നർ: കണ്ടെയ്നർ ഇമേജിന്റെ എക്സിക്യൂട്ടബിൾ ഉദാഹരണം.
• കണ്ടെയ്നർ എഞ്ചിൻ: കണ്ടെയ്നർ പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള ഉത്തരവാദിത്തമുള്ള ഡെമൺ പ്രക്രിയ.
• കണ്ടെയ്നർ ഹോസ്റ്റ്: കണ്ടെയ്നർ എഞ്ചിൻ പ്രവർത്തിക്കുന്ന ഹോസ്റ്റ് കമ്പ്യൂട്ടർ.
• കണ്ടെയ്നർ രജിസ്ട്രി: കണ്ടെയ്‌നർ ചിത്രം പ്രസിദ്ധീകരിക്കുന്നതിനും വിതരണം ചെയ്യുന്നതിനും ഉപയോഗിക്കുന്ന പൊതുവായ ലൊക്കേഷൻ.
• 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അഭ്യർത്ഥനകൾ കേൾക്കും.

ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്നു

ആദ്യം നിങ്ങൾ Maven അല്ലെങ്കിൽ Gradle ഉപയോഗിച്ച് ഒരു ആപ്ലിക്കേഷൻ സൃഷ്ടിക്കേണ്ടതുണ്ട്. ഇവിടെ ഞങ്ങൾ Maven ഉപയോഗിക്കുന്നു:

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-ൽ ഹെറോകു സമാരംഭിച്ചു, അതിനുശേഷം ക്ലൗഡ് ഫൗണ്ടറി, ഗൂഗിൾ ആപ്പ് എഞ്ചിൻ, ഗിറ്റ്‌ലാബ്, ക്നേറ്റീവ് എന്നിവയും മറ്റ് നിരവധി സ്ഥാപനങ്ങളും ഇത് സ്വീകരിച്ചു.

ക്ലൗഡ് ബിൽഡ് പാക്കേജുകളുടെ പ്രയോജനം

ഇമേജുകൾ സൃഷ്ടിക്കാൻ ബിൽഡ്പാക്ക് ഉപയോഗിക്കുന്നതിന്റെ ഒരു പ്രധാന നേട്ടം ഇതാണ് ഇമേജ് കോൺഫിഗറേഷൻ മാറ്റങ്ങൾ കേന്ദ്രീകൃതമായി (ബിൽഡർ) കൈകാര്യം ചെയ്യാനും ബിൽഡർ ഉപയോഗിച്ച് എല്ലാ ആപ്ലിക്കേഷനുകളിലേക്കും പ്രചരിപ്പിക്കാനും കഴിയും.

ബിൽഡ് പാക്കേജുകൾ പ്ലാറ്റ്‌ഫോമിലേക്ക് കർശനമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു. ക്ലൗഡ്-നേറ്റീവ് ബിൽഡ്‌പാക്കുകൾ 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>

അടുത്തതായി, ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്നതിനും ഒരു കണ്ടെയ്നർ ഇമേജ് സൃഷ്ടിക്കുന്നതിനും ഞങ്ങൾ Maven കമാൻഡ് ഉപയോഗിച്ച് Jib പ്ലഗിൻ പ്രവർത്തിപ്പിക്കുന്നു. മുമ്പത്തെപ്പോലെ, ഞങ്ങൾ ഇവിടെ ഡോക്കർ ഫയലുകളൊന്നും ഉപയോഗിക്കുന്നില്ല:

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 പൈപ്പ് ലൈനുകളിൽ ദൈർഘ്യമേറിയ നിർമ്മാണ സമയത്തിനും കാരണമാകുന്നു.
• സുരക്ഷ: വലിയ ചിത്രങ്ങൾക്ക് കേടുപാടുകൾക്കുള്ള വലിയൊരു ഏരിയയും ഉണ്ട്.

ഒരു ഡോക്കർ ഇമേജിൽ ലെയറുകളുടെ ഒരു ശേഖരം അടങ്ങിയിരിക്കുന്നു, അവ ഓരോന്നും ഞങ്ങളുടെ ഡോക്കർഫയലിലെ ഒരു നിർദ്ദേശത്തെ പ്രതിനിധീകരിക്കുന്നു. ഓരോ ലെയറും അണ്ടർലയിംഗ് ലെയറിലെ മാറ്റങ്ങളുടെ ഒരു ഡെൽറ്റയെ പ്രതിനിധീകരിക്കുന്നു. നമ്മൾ രജിസ്ട്രിയിൽ നിന്ന് ഒരു ഡോക്കർ ഇമേജ് വലിക്കുമ്പോൾ, അത് ലെയറുകളായി വലിച്ച് ഹോസ്റ്റിൽ കാഷെ ചെയ്യുന്നു.

സ്പ്രിംഗ് ബൂട്ട് ഉപയോഗിക്കുന്നു "കൊഴുപ്പ് ജാർ" ഡിഫോൾട്ട് പാക്കേജിംഗ് ഫോർമാറ്റായി. കട്ടിയുള്ള 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 ഇമേജ് സൃഷ്ടിക്കാനും കഴിയും.

ഞങ്ങൾ ഡോക്കർ ഉപയോഗിക്കുമ്പോൾ, ലെയറുകൾ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യാനും അവ അന്തിമ ചിത്രത്തിലേക്ക് പകർത്താനും ഞങ്ങൾ രണ്ട് അധിക ഘട്ടങ്ങൾ ചെയ്യേണ്ടതുണ്ട്.

ലേയറിംഗ് പ്രവർത്തനക്ഷമമാക്കി 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

സ്‌നാപ്‌ഷോട്ട് അടങ്ങിയിട്ടില്ലാത്ത ഏതെങ്കിലും ആശ്രിതത്വം

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 ഫയൽ സൃഷ്‌ടിക്കുക, തുടർന്ന് ഡോക്കർ ഫയലിലെ നിർദ്ദേശങ്ങൾ വ്യക്തമാക്കി ഒരു കണ്ടെയ്‌നർ ഇമേജിലേക്ക് പാക്കേജ് ചെയ്യുക.

ഹോസ്റ്റിൽ കാഷെ ചെയ്‌തിരിക്കുന്ന പ്രത്യേക ലെയറുകളിലേക്ക് ഡിപൻഡൻസികളെ വലിക്കുന്ന ഒരു ലേയറിംഗ് ഫീച്ചർ പ്രവർത്തനക്ഷമമാക്കി ഞങ്ങളുടെ കണ്ടെയ്‌നർ ഒപ്റ്റിമൈസ് ചെയ്യുന്നതും ഞങ്ങൾ നോക്കി.

ലേഖനത്തിൽ ഉപയോഗിച്ചിരിക്കുന്ന എല്ലാ സോഴ്സ് കോഡും നിങ്ങൾക്ക് ഇവിടെ കണ്ടെത്താനാകും സാമൂഹികം .

കമാൻഡ് റഫറൻസ്

ഈ ലേഖനത്തിൽ ഞങ്ങൾ ഉപയോഗിച്ച കമാൻഡുകളുടെ ഒരു ദ്രുത അവലോകനം ഇതാ.

സന്ദർഭ ക്ലിയറിംഗ്:

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