ਸਪਰਿੰਗ ਬੂਟ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਅਨੁਕੂਲਿਤ ਡੌਕਰ ਚਿੱਤਰ ਬਣਾਉਣਾ

ਕੰਟੇਨਰ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇਸਦੇ ਸਾਰੇ ਸੌਫਟਵੇਅਰ ਅਤੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨਿਰਭਰਤਾ ਦੇ ਨਾਲ ਪੈਕ ਕਰਨ ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ ਵੱਖ-ਵੱਖ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਪ੍ਰਦਾਨ ਕਰਨ ਦੇ ਤਰਜੀਹੀ ਸਾਧਨ ਬਣ ਗਏ ਹਨ।

ਇਹ ਲੇਖ ਸਪਰਿੰਗ ਬੂਟ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਕੰਟੇਨਰਾਈਜ਼ ਕਰਨ ਦੇ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ:

• ਇੱਕ ਡੌਕਰ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਡੌਕਰ ਚਿੱਤਰ ਬਣਾਉਣਾ,
• ਕਲਾਉਡ-ਨੇਟਿਵ ਬਿਲਡਪੈਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਰੋਤ ਤੋਂ ਇੱਕ 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ਜੋ ਬੇਨਤੀਆਂ ਸੁਣੇਗਾ।

ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣਾ

ਪਹਿਲਾਂ ਤੁਹਾਨੂੰ Maven ਜਾਂ Gradle ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ। ਇੱਥੇ ਅਸੀਂ ਮਾਵੇਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ:

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 ਦੁਆਰਾ ਲਾਂਚ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਉਦੋਂ ਤੋਂ ਕਲਾਊਡ ਫਾਊਂਡਰੀ, ਗੂਗਲ ਐਪ ਇੰਜਨ, ਗਿਟਲਬ, ਨੈਟਿਵ ਅਤੇ ਕਈ ਹੋਰਾਂ ਦੁਆਰਾ ਅਪਣਾਇਆ ਗਿਆ ਹੈ।

ਕਲਾਉਡ ਬਿਲਡ ਪੈਕੇਜਾਂ ਦਾ ਫਾਇਦਾ

ਚਿੱਤਰ ਬਣਾਉਣ ਲਈ ਬਿਲਡਪੈਕ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਮੁੱਖ ਲਾਭਾਂ ਵਿੱਚੋਂ ਇੱਕ ਇਹ ਹੈ ਕਿ ਚਿੱਤਰ ਸੰਰਚਨਾ ਤਬਦੀਲੀਆਂ ਨੂੰ ਕੇਂਦਰੀ ਤੌਰ 'ਤੇ ਪ੍ਰਬੰਧਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ (ਬਿਲਡਰ) ਅਤੇ ਬਿਲਡਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਾਰੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਪ੍ਰਸਾਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਬਿਲਡ ਪੈਕੇਜਾਂ ਨੂੰ ਪਲੇਟਫਾਰਮ ਨਾਲ ਮਜ਼ਬੂਤੀ ਨਾਲ ਜੋੜਿਆ ਗਿਆ ਸੀ। ਕਲਾਉਡ-ਨੇਟਿਵ ਬਿਲਡਪੈਕਸ 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-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

ਆਉਟਪੁੱਟ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਕੰਟੇਨਰ ਚਿੱਤਰ ਬਣਾਇਆ ਗਿਆ ਹੈ ਅਤੇ ਰਜਿਸਟਰੀ ਵਿੱਚ ਰੱਖਿਆ ਗਿਆ ਹੈ।

ਅਨੁਕੂਲਿਤ ਚਿੱਤਰ ਬਣਾਉਣ ਲਈ ਪ੍ਰੇਰਣਾ ਅਤੇ ਤਕਨੀਕਾਂ

ਸਾਡੇ ਕੋਲ ਅਨੁਕੂਲਨ ਦੇ ਦੋ ਮੁੱਖ ਕਾਰਨ ਹਨ:

• ਉਤਪਾਦਕਤਾ: ਇੱਕ ਕੰਟੇਨਰ ਆਰਕੈਸਟਰੇਸ਼ਨ ਸਿਸਟਮ ਵਿੱਚ, ਇੱਕ ਕੰਟੇਨਰ ਚਿੱਤਰ ਨੂੰ ਚਿੱਤਰ ਰਜਿਸਟਰੀ ਤੋਂ ਕੰਟੇਨਰ ਇੰਜਣ ਨੂੰ ਚਲਾਉਣ ਵਾਲੇ ਹੋਸਟ ਨੂੰ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਯੋਜਨਾਬੰਦੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਰਜਿਸਟਰੀ ਤੋਂ ਵੱਡੇ ਚਿੱਤਰਾਂ ਨੂੰ ਖਿੱਚਣ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਕੰਟੇਨਰ ਆਰਕੈਸਟ੍ਰੇਸ਼ਨ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ ਲੰਮਾ ਸਮਾਂ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਸੀਆਈ ਪਾਈਪਲਾਈਨਾਂ ਵਿੱਚ ਲੰਬੇ ਸਮੇਂ ਦਾ ਨਿਰਮਾਣ ਹੁੰਦਾ ਹੈ।
• ਸੁਰੱਖਿਆ ਨੂੰ: ਵੱਡੇ ਚਿੱਤਰਾਂ ਵਿੱਚ ਕਮਜ਼ੋਰੀਆਂ ਲਈ ਇੱਕ ਵੱਡਾ ਖੇਤਰ ਵੀ ਹੁੰਦਾ ਹੈ।

ਇੱਕ ਡੌਕਰ ਚਿੱਤਰ ਵਿੱਚ ਲੇਅਰਾਂ ਦਾ ਇੱਕ ਸਟੈਕ ਹੁੰਦਾ ਹੈ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ ਸਾਡੀ ਡੌਕਰਫਾਈਲ ਵਿੱਚ ਇੱਕ ਹਦਾਇਤ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਹਰੇਕ ਲੇਅਰ ਅੰਡਰਲਾਈੰਗ ਲੇਅਰ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਦਾ ਇੱਕ ਡੈਲਟਾ ਦਰਸਾਉਂਦੀ ਹੈ। ਜਦੋਂ ਅਸੀਂ ਰਜਿਸਟਰੀ ਤੋਂ ਇੱਕ ਡੌਕਰ ਚਿੱਤਰ ਨੂੰ ਖਿੱਚਦੇ ਹਾਂ, ਤਾਂ ਇਹ ਲੇਅਰਾਂ ਵਿੱਚ ਖਿੱਚਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਹੋਸਟ 'ਤੇ ਕੈਸ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਬਸੰਤ ਬੂਟ ਵਰਤਦਾ ਹੈ "ਚਰਬੀ 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 ਨਾਲ ਬਣਾਇਆ ਗਿਆ ਹੈ ਅਤੇ ਫਿਰ ਟੈਗ ਕੀਤਾ ਗਿਆ ਹੈ.

ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਤਿਆਰ ਕੀਤੇ ਡੌਕਰ ਚਿੱਤਰ ਦੇ ਅੰਦਰ ਲੇਅਰਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਪਹਿਲਾਂ ਵਾਂਗ ਡਾਈਵ ਕਮਾਂਡ ਚਲਾਉਂਦੇ ਹਾਂ। ਅਸੀਂ ਡਾਈਵ ਕਮਾਂਡ ਨੂੰ ਇਨਪੁਟ ਵਜੋਂ ਇੱਕ ਚਿੱਤਰ 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 ਫਾਈਲ ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਲੇਅਰਿੰਗ ਵਿਸ਼ੇਸ਼ਤਾ spring-boot-maven-plugin ਵਿੱਚ ਸਮਰੱਥ ਹੈ:

java -Djarmode=layertools -jar application.jar list

ਨਿਰਭਰਤਾ ਪਰਤਾਂ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਨਾ। ਐਪਲੀਕੇਸ਼ਨ JAR ਫਾਈਲ ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਲੇਅਰਿੰਗ ਵਿਸ਼ੇਸ਼ਤਾ spring-boot-maven-plugin ਵਿੱਚ ਸਮਰੱਥ ਹੈ:

 java -Djarmode=layertools -jar application.jar extract

ਕੰਟੇਨਰ ਚਿੱਤਰਾਂ ਦੀ ਸੂਚੀ ਵੇਖੋ

docker images

ਕੰਟੇਨਰ ਚਿੱਤਰ ਦੇ ਅੰਦਰ ਖੱਬੇ ਪਾਸੇ ਦੇਖੋ (ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਡਾਈਵ ਟੂਲ ਇੰਸਟਾਲ ਹੈ):

dive <image ID or image tag>

ਸਰੋਤ: www.habr.com