Δημιουργία βελτιστοποιημένων εικόνων Docker για μια εφαρμογή Spring Boot

Τα κοντέινερ έχουν γίνει το προτιμώμενο μέσο συσκευασίας μιας εφαρμογής με όλες τις εξαρτήσεις του λογισμικού και του λειτουργικού συστήματος και στη συνέχεια την παράδοσή τους σε διαφορετικά περιβάλλοντα.

Αυτό το άρθρο καλύπτει διάφορους τρόπους για τη δημιουργία κοντέινερ μιας εφαρμογής Spring Boot:

• δημιουργία μιας εικόνας docker χρησιμοποιώντας ένα αρχείο docker,
• δημιουργία εικόνας OCI από την πηγή χρησιμοποιώντας το Cloud-Native Buildpack,
• και βελτιστοποίηση εικόνας κατά το χρόνο εκτέλεσης με το διαχωρισμό των τμημάτων JAR σε διαφορετικά επίπεδα χρησιμοποιώντας εργαλεία σε επίπεδα.

 Παράδειγμα κώδικα

Αυτό το άρθρο συνοδεύεται από ένα παράδειγμα κώδικα εργασίας στο GitHub .

Ορολογία κοντέινερ

Θα ξεκινήσουμε με την ορολογία του κοντέινερ που χρησιμοποιείται σε όλο το άρθρο:

• Εικόνα κοντέινερ: αρχείο συγκεκριμένης μορφής. Μετατρέπουμε την εφαρμογή μας σε εικόνα κοντέινερ εκτελώντας το εργαλείο δημιουργίας.
• Δοχείο: Μια εκτελέσιμη παρουσία της εικόνας κοντέινερ.
• Κινητήρας κοντέινερ: Η διαδικασία δαίμονα που είναι υπεύθυνη για τη λειτουργία του κοντέινερ.
• οικοδεσπότης κοντέινερ: Το μηχάνημα υποδοχής στο οποίο λειτουργεί ο κινητήρας κοντέινερ.
• Μητρώο κοντέινερ: Η γενική τοποθεσία που χρησιμοποιείται για τη δημοσίευση και τη διανομή της εικόνας του κοντέινερ.
• Πρότυπο OCI: Open Container Initiative (OCI) είναι ένα ελαφρύ πλαίσιο διαχείρισης ανοιχτού κώδικα που δημιουργήθηκε από το Linux Foundation. Η προδιαγραφή εικόνας OCI ορίζει τα βιομηχανικά πρότυπα για τις μορφές εικόνων κοντέινερ και το χρόνο εκτέλεσης για να διασφαλίσει ότι όλες οι μηχανές κοντέινερ μπορούν να εκτελούν εικόνες κοντέινερ που δημιουργούνται από οποιοδήποτε εργαλείο κατασκευής.

Για τη δημιουργία κοντέινερ μιας εφαρμογής, τυλίγουμε την αίτησή μας σε μια εικόνα κοντέινερ και δημοσιεύουμε αυτήν την εικόνα στο δημόσιο μητρώο. Ο χρόνος εκτέλεσης κοντέινερ ανακτά αυτήν την εικόνα από το μητρώο, την αποσυσκευάζει και εκτελεί την εφαρμογή μέσα σε αυτό.

Η έκδοση 2.3 του Spring Boot παρέχει πρόσθετα για τη δημιουργία εικόνων OCI.

Λιμενεργάτης είναι η πιο συχνά χρησιμοποιούμενη υλοποίηση κοντέινερ και χρησιμοποιούμε το Docker στα παραδείγματά μας, επομένως όλες οι επόμενες αναφορές κοντέινερ σε αυτό το άρθρο θα αναφέρονται στο Docker.

Δημιουργία εικόνας κοντέινερ με τον παραδοσιακό τρόπο

Η δημιουργία εικόνων Docker για εφαρμογές Spring Boot είναι πολύ εύκολη προσθέτοντας μερικές οδηγίες στο Dockerfile σας.

Δημιουργούμε πρώτα ένα εκτελέσιμο JAR και, ως μέρος των οδηγιών του Dockerfile, αντιγράφουμε το εκτελέσιμο JAR πάνω από τη βασική εικόνα JRE αφού εφαρμόσουμε τις απαραίτητες προσαρμογές.

Ας δημιουργήσουμε την εφαρμογή μας για την Άνοιξη Spring Initializr με εξαρτήσεις web, lombokи actuator. Προσθέτουμε επίσης έναν ελεγκτή ανάπαυσης για να παρέχουμε ένα API GETμέθοδος.

Δημιουργία αρχείου Docker

Στη συνέχεια τοποθετούμε αυτή την εφαρμογή σε ένα δοχείο προσθέτοντας 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 σε εικόνα Docker για να εκτελεστεί στη μηχανή Docker.

Δημιουργήστε μια εικόνα κοντέινερ

Στη συνέχεια, βάζουμε αυτό το εκτελέσιμο JAR στην εικόνα Docker εκτελώντας την εντολή docker buildαπό τον ριζικό κατάλογο του έργου που περιέχει το Dockerfile που δημιουργήθηκε νωρίτερα:

docker build  -t usersignup:v1 .

Μπορούμε να δούμε την εικόνα μας στη λίστα με την εντολή:

docker images 

Η έξοδος της παραπάνω εντολής περιλαμβάνει την εικόνα μας usersignupμαζί με την εικόνα βάσης, adoptopenjdkπου καθορίζεται στο Dockerfile μας.

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

Προβολή επιπέδων μέσα σε μια εικόνα κοντέινερ

Ας δούμε τη στοίβα των στρωμάτων μέσα στην εικόνα. Θα το χρησιμοποιησουμε εργαλείο  κατάδυση, για να δείτε αυτά τα επίπεδα:

dive usersignup:v1

Εδώ είναι μέρος της εξόδου της εντολής Dive: 

Όπως μπορούμε να δούμε, το επίπεδο εφαρμογής αποτελεί σημαντικό μέρος του μεγέθους της εικόνας. Θέλουμε να μειώσουμε το μέγεθος αυτού του επιπέδου στις ακόλουθες ενότητες ως μέρος της βελτιστοποίησής μας.

Δημιουργία εικόνας κοντέινερ με το Buildpack

Πακέτα συναρμολόγησης (Buildpacks) είναι ένας γενικός όρος που χρησιμοποιείται από διάφορες προσφορές Πλατφόρμας ως Υπηρεσίας (PAAS) για τη δημιουργία μιας εικόνας κοντέινερ από τον πηγαίο κώδικα. Κυκλοφόρησε από την Heroku το 2011 και έκτοτε υιοθετήθηκε από το Cloud Foundry, το Google App Engine, το Gitlab, το Knative και μερικούς άλλους.

Πλεονέκτημα των πακέτων Cloud Build

Ένα από τα κύρια πλεονεκτήματα της χρήσης του Buildpack για τη δημιουργία εικόνων είναι ότι Οι αλλαγές στη διαμόρφωση της εικόνας μπορούν να διαχειρίζονται κεντρικά (δημιουργός) και να διαδοθούν σε όλες τις εφαρμογές χρησιμοποιώντας το πρόγραμμα δημιουργίας.

Τα πακέτα κατασκευής ήταν στενά συνδεδεμένα με την πλατφόρμα. Τα Cloud-Native Buildpacks παρέχουν τυποποίηση σε όλες τις πλατφόρμες υποστηρίζοντας τη μορφή εικόνας OCI, η οποία διασφαλίζει ότι η εικόνα μπορεί να εκτελεστεί από τη μηχανή Docker.

Χρήση της προσθήκης Spring Boot

Η προσθήκη Spring Boot δημιουργεί εικόνες OCI από την πηγή χρησιμοποιώντας το Buildpack. Οι εικόνες δημιουργούνται χρησιμοποιώντας bootBuildImageεργασίες (Gradle) ή spring-boot:build-imageστόχος (Maven) και τοπική εγκατάσταση Docker.

Μπορούμε να προσαρμόσουμε το όνομα της εικόνας που πρέπει να προωθήσουμε στο μητρώο του Docker, καθορίζοντας το όνομα στο 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>

Ας χρησιμοποιήσουμε το Maven για εκτέλεση build-imageστόχους για τη δημιουργία μιας εφαρμογής και τη δημιουργία μιας εικόνας κοντέινερ. Προς το παρόν δεν χρησιμοποιούμε Dockerfiles.

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 εκτελώντας την εντολή:

docker images 

Συμπέρασμα:

REPOSITORY                             SIZE
paketobuildpacks/run                  84.3MB
gcr.io/paketo-buildpacks/builder      652MB
pratikdas/usersignup                  257MB

Δημιουργία εικόνας κοντέινερ με το Jib

Το Jib είναι μια προσθήκη δημιουργίας εικόνων από την Google που παρέχει μια εναλλακτική μέθοδο δημιουργίας μιας εικόνας κοντέινερ από την πηγή.

Εγκαθιστώ jib-maven-pluginστο pom.xml:

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

Στη συνέχεια, εκτελούμε την προσθήκη Jib χρησιμοποιώντας την εντολή Maven για να δημιουργήσουμε την εφαρμογή και να δημιουργήσουμε την εικόνα του κοντέινερ. Όπως και πριν, δεν χρησιμοποιούμε κανένα Dockerfiles εδώ:

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.
• Ασφάλεια: οι μεγάλες εικόνες έχουν επίσης μεγάλη περιοχή για τρωτά σημεία.

Μια εικόνα Docker αποτελείται από μια στοίβα επιπέδων, καθένα από τα οποία αντιπροσωπεύει μια δήλωση στο αρχείο μας Docker. Κάθε στρώμα αντιπροσωπεύει το δέλτα των αλλαγών στο υποκείμενο στρώμα. Όταν τραβάμε μια εικόνα Docker από το μητρώο, τραβιέται σε επίπεδα και αποθηκεύεται προσωρινά στον κεντρικό υπολογιστή.

Χρήσεις Spring Boot «παχύ Βάζο» σε ως προεπιλεγμένη μορφή συσκευασίας. Όταν κοιτάμε ένα παχύ JAR, βλέπουμε ότι η εφαρμογή είναι ένα πολύ μικρό μέρος ολόκληρου του JAR. Αυτό είναι το κομμάτι που αλλάζει περισσότερο. Το υπόλοιπο αποτελείται από εξαρτήσεις Spring Framework.

Ο τύπος βελτιστοποίησης επικεντρώνεται στην απομόνωση της εφαρμογής σε ξεχωριστό επίπεδο από τις εξαρτήσεις του Spring Framework.

Το επίπεδο εξάρτησης που αποτελεί το μεγαλύτερο μέρος του παχύ αρχείου JAR λαμβάνεται μόνο μία φορά και αποθηκεύεται προσωρινά στο κεντρικό σύστημα.

Μόνο ένα λεπτό στρώμα της εφαρμογής τραβιέται κατά τις ενημερώσεις εφαρμογών και τον προγραμματισμό κοντέινερ, όπως φαίνεται σε αυτό το διάγραμμα:

Στις επόμενες ενότητες, θα δούμε πώς να δημιουργήσετε αυτές τις βελτιστοποιημένες εικόνες για μια εφαρμογή Spring Boot.

Δημιουργία βελτιστοποιημένης εικόνας κοντέινερ για εφαρμογή Spring Boot με το Buildpack

Το Spring Boot 2.3 υποστηρίζει layering εξάγοντας τμήματα ενός παχύ αρχείου JAR σε ξεχωριστά επίπεδα. Η δυνατότητα επίστρωσης είναι απενεργοποιημένη από προεπιλογή και πρέπει να ενεργοποιηθεί ρητά χρησιμοποιώντας την προσθήκη Spring Boot Maven:

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

Θα χρησιμοποιήσουμε αυτήν τη διαμόρφωση για να δημιουργήσουμε την εικόνα του κοντέινερ πρώτα με το Buildpack και μετά με το Docker στις ακόλουθες ενότητες.

Ας τρέξουμε build-imageΤο Maven στοχεύει να δημιουργήσει μια εικόνα κοντέινερ:

mvn spring-boot:build-image

Εάν εκτελέσουμε το Dive για να δούμε τα επίπεδα στην εικόνα που προκύπτει, μπορούμε να δούμε ότι το επίπεδο εφαρμογής (κυκλωμένο με κόκκινο χρώμα) είναι πολύ μικρότερο στο εύρος των kilobyte σε σύγκριση με αυτό που λάβαμε χρησιμοποιώντας την παχιά μορφή JAR:

Δημιουργία μιας βελτιστοποιημένης εικόνας κοντέινερ για μια εφαρμογή Spring Boot με το Docker

Αντί να χρησιμοποιήσουμε ένα πρόσθετο Maven ή Gradle, μπορούμε επίσης να δημιουργήσουμε μια εικόνα Docker JAR σε επίπεδα με ένα αρχείο Docker.

Όταν χρησιμοποιούμε το Docker, πρέπει να κάνουμε δύο επιπλέον βήματα για να εξαγάγουμε τα επίπεδα και να τα αντιγράψουμε στην τελική εικόνα.

Τα περιεχόμενα του προκύπτοντος JAR μετά την κατασκευή με το Maven με ενεργοποιημένο το layering θα μοιάζουν με αυτό:

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-layertoolsJAR αντί για εφαρμογή:

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αρχείο με τη σειρά με την οποία πρέπει να προστεθούν στην εικόνα Docker. Αυτά τα επίπεδα αποθηκεύονται προσωρινά στον κεντρικό υπολογιστή μετά την πρώτη ανάκτηση επειδή δεν αλλάζουν. Μόνο το ενημερωμένο επίπεδο εφαρμογής γίνεται λήψη στον κεντρικό υπολογιστή, το οποίο είναι ταχύτερο λόγω του μειωμένου μεγέθους .

Δημιουργία εικόνας με εξαρτήσεις που εξάγονται σε ξεχωριστά επίπεδα

Θα δημιουργήσουμε την τελική εικόνα σε δύο βήματα χρησιμοποιώντας μια μέθοδο που ονομάζεται συναρμολόγηση πολλαπλών σταδίων . Στο πρώτο βήμα θα εξαγάγουμε τις εξαρτήσεις και στο δεύτερο βήμα θα αντιγράψουμε τις εξαγόμενες εξαρτήσεις στο τελικό.

Ας τροποποιήσουμε το 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 χρησιμοποιώντας την εντολή:

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

Μπορούμε να δούμε ότι η εικόνα Docker δημιουργείται με ένα αναγνωριστικό εικόνας και στη συνέχεια επισημαίνεται.

Τέλος, εκτελούμε την εντολή Dive όπως πριν για να ελέγξουμε τα επίπεδα μέσα στην εικόνα Docker που δημιουργήθηκε. Μπορούμε να παρέχουμε ένα αναγνωριστικό εικόνας ή μια ετικέτα ως είσοδο στην εντολή Dive:

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που περιέχει εξαρτήσεις οργανισμού που ανακτήθηκαν από τον κοινόχρηστο χώρο αποθήκευσης.

Παραγωγή

Σε αυτό το άρθρο, εξετάσαμε τη χρήση των Cloud-Native Buildpacks για τη δημιουργία μιας εικόνας κοντέινερ απευθείας από την πηγή. Αυτή είναι μια εναλλακτική λύση στη χρήση του Docker για τη δημιουργία μιας εικόνας κοντέινερ με τον συνηθισμένο τρόπο: πρώτα, δημιουργείται ένα παχύ εκτελέσιμο αρχείο JAR και στη συνέχεια συσκευάζεται σε μια εικόνα κοντέινερ καθορίζοντας τις οδηγίες στο Dockerfile.

Εξετάσαμε επίσης τη βελτιστοποίηση του κοντέινερ μας συμπεριλαμβάνοντας μια δυνατότητα στρώσης που εξάγει τις εξαρτήσεις σε ξεχωριστά επίπεδα που αποθηκεύονται προσωρινά στον κεντρικό υπολογιστή και ένα λεπτό στρώμα εφαρμογής φορτώνεται κατά τον χρόνο προγραμματισμού στις μηχανές εκτέλεσης του κοντέινερ.

Μπορείτε να βρείτε όλο τον πηγαίο κώδικα που χρησιμοποιείται στο άρθρο στη διεύθυνση Github .

Αναφορά εντολών

Ακολουθεί μια σύνοψη των εντολών που χρησιμοποιήσαμε σε αυτό το άρθρο για μια γρήγορη αναφορά.

Εκκαθάριση περιβάλλοντος:

docker system prune -a

Δημιουργία εικόνας κοντέινερ με αρχείο Docker:

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

Δημιουργία εικόνας κοντέινερ από την πηγή (χωρίς Dockerfile):

mvn spring-boot:build-image

Προβολή επιπέδων εξάρτησης. Πριν δημιουργήσετε το αρχείο jar της εφαρμογής, βεβαιωθείτε ότι η δυνατότητα layering είναι ενεργοποιημένη στην προσθήκη spring-boot-maven-plugin:

java -Djarmode=layertools -jar application.jar list

Εξαγωγή επιπέδων εξάρτησης. Πριν δημιουργήσετε το αρχείο jar της εφαρμογής, βεβαιωθείτε ότι η δυνατότητα layering είναι ενεργοποιημένη στην προσθήκη spring-boot-maven-plugin:

 java -Djarmode=layertools -jar application.jar extract

Προβολή λίστας εικόνων κοντέινερ

docker images

Προβολή στα αριστερά μέσα στην εικόνα του κοντέινερ (βεβαιωθείτε ότι το εργαλείο κατάδυσης είναι εγκατεστημένο):

dive <image ID or image tag>

Πηγή: www.habr.com