Einführung

Sie haben eine Spring Boot-Anwendung erstellt. Es funktioniert hervorragend auf Ihrem lokalen Computer und jetzt müssen Sie die Anwendung woanders bereitstellen. Auf einigen Plattformen können Sie die JAR-Datei direkt übermitteln und sie wird bereitgestellt. An manchen Orten können Sie eine virtuelle Maschine starten, dort den Quellcode herunterladen, ihn erstellen und ausführen. Meistens müssen Sie die Anwendung jedoch mithilfe von Containern bereitstellen. Meistens wird Docker verwendet, um das Image in einem Container zu erstellen und auszuführen. Wenn Sie die JAR-Datei auf einige Plattformen hochladen, wird die Anwendung außerdem in einem Container unter der Haube ausgeführt.

In diesem Blog werden wir also drei verschiedene Möglichkeiten sehen, ein Docker-Image für die jeweilige Spring Boot-Anwendung zu erstellen. Fangen wir an:

Grundlegendes Container-Image

Der naive und unzureichende Weg, das Docker-Image für jede Anwendung zu erstellen, besteht darin, eine einfache Docker-Datei zu verwenden, die die JAR-Datei in das Image kopiert und sie mit dem Befehl java -jar ausführt.

Erstellen Sie eine Docker-Datei

Hier ist die Docker-Datei, die Sie im Stammverzeichnis des Projekts ablegen können:

FROM eclipse-temurin:21-jre-ubi9-minimal

ARG JAR_FILE

COPY ${JAR_FILE} application.jar

ENTRYPOINT ["java", "-jar", "/application.jar"]

Wir haben ein Argument JAR_FILE angegeben, das den Speicherort der zu verwendenden JAR-Datei angibt.

Docker-Image erstellen

Nachdem die obige Docker-Datei erstellt wurde, werden die folgenden Schritte verwendet, um das Docker-Image zu erstellen:

1. Erstellen Sie die JAR-Datei für das Spring Boot-Projekt:
   

   ./gradlew bootJar # For Gradle build system
   

   ODER
   

   ./mvnw spring-boot:build-jar # For Maven build system
   

2. Verwenden Sie die Docker-Datei, um das Docker-Image mit der neuesten JAR-Datei zu erstellen. Ersetzen Sie im folgenden Befehl {IMAGE_NAME} durch den erforderlichen Bildnamen und {JAR_FILE} durch den Pfad zur generierten JAR-Datei. Der Bildname enthält auch ein Tag, etwa - mycompany/product-service:0.0.1-SNAPSHOT:
   

   docker build --build-arg JAR_FILE={JAR_FILE} --tag {IMAGE_NAME} .
   

3. Überprüfen Sie mit dem folgenden Befehl, ob das Docker-Image erstellt wurde. Sie sollten das Bild mit dem im obigen Befehl angegebenen Namen sehen können:
   

   docker images
   

Effizientes Container-Image mit Layered Jar

Obwohl es möglich und einfach ist, ein Spring Boot-Uber-Jar als Docker-Image zu packen (wie in der vorherigen Methode erwähnt), hat das Kopieren und Ausführen des Fat-Jars im Docker-Image viele Nachteile. Zum Beispiel,

• Es entsteht ein gewisser Mehraufwand, wenn Uber Jar ausgeführt wird, ohne es zu entpacken.
• Es ist nicht optimal, den Code der Anwendung und alle ihre Abhängigkeiten in einer einzigen Ebene unterzubringen.

Da wir unseren Code häufiger kompilieren als die Spring Boot-Version aktualisieren, ist es besser, die Dinge etwas stärker zu trennen. Wenn wir diese JAR-Dateien (die selten geändert werden) in der Ebene vor der Anwendungsebene ablegen, muss Docker oft nur die unterste Ebene ändern und kann den Rest aus seinem Cache auswählen.

Aktivieren Sie Layered Jar

Um ein mehrschichtiges Docker-Image zu erstellen, müssen wir zuerst ein mehrschichtiges JAR erstellen. Heutzutage ist es in Gradle und Maven standardmäßig aktiviert. Sie können das mehrschichtige JAR-Verhalten mit der folgenden Einstellung aktivieren oder deaktivieren:

// build.gradle
tasks.named("bootJar") {
    layered {
        enabled = false
    }
}

// build.gradle.kts
tasks.named("bootJar") {
   layered {
      enabled.set(false)
   }
}

   
      
         
            org.springframework.boot
            spring-boot-maven-plugin
            
               
                  true
               
            
         
      
   

Sie können sogar anpassen, wie die Ebenen erstellt werden. Informationen zur Gradle- oder Maven-Konfiguration finden Sie in der Dokumentation.

Erstellen Sie eine Docker-Datei

Unten finden Sie die Docker-Datei, mit der Sie die Vorteile des mehrschichtigen JAR nutzen und ein mehrschichtiges Docker-Image der Spring Boot-Anwendung erstellen können.

# Perform the extraction in a separate builder container
FROM eclipse-temurin:21-jre-ubi9-minimal AS builder

WORKDIR /builder

# This points to the built jar file in the target folder
# Adjust this to 'build/libs/*.jar' if you're using Gradle
ARG JAR_FILE=target/*.jar

# Copy the jar file to the working directory and rename it to application.jar
COPY ${JAR_FILE} application.jar

# Extract the jar file using an efficient layout
RUN java -Djarmode=tools -jar application.jar extract --layers --destination extracted

# This is the runtime container
FROM eclipse-temurin:21-jre-ubi9-minimal

WORKDIR /application

# Copy the extracted jar contents from the builder container into the working directory in the runtime container
# Every copy step creates a new docker layer
# This allows docker to only pull the changes it really needs
COPY --from=builder /builder/extracted/dependencies/ ./
COPY --from=builder /builder/extracted/spring-boot-loader/ ./
COPY --from=builder /builder/extracted/snapshot-dependencies/ ./
COPY --from=builder /builder/extracted/application/ ./

# Start the application jar - this is not the uber jar used by the builder
# This jar only contains application code and references to the extracted jar files
# This layout is efficient to start up and CDS friendly
ENTRYPOINT ["java", "-jar", "application.jar"]

Docker-Image erstellen

Die Schritte zum Erstellen des mehrschichtigen Docker-Images sind dieselben wie zum Erstellen eines einfachen Docker-Images. Bitte schauen Sie dort nach.

Cloud Native Buildpacks

Was wäre, wenn ich Ihnen sage, dass Sie ein Docker-Image erstellen können, ohne eine Docker-Datei zu erstellen? Mit Cloud Native Buildpacks können wir Docker-Images direkt aus dem Gralde- oder Maven-Plugin erstellen. Einige Plattformen (wie Heroku oder Cloud Foundry) verwenden Buildpacks, um bereitgestellte JAR-Dateien in ausführbare Bilder zu konvertieren.

Spring Boot bietet Buildpack-Unterstützung direkt für Maven und Gradle. Wir müssen keine zusätzlichen Plugins einbinden. Führen Sie einfach den folgenden Befehl aus:

./gradlew bootBuildImage # For gradle build system

ODER

./mvnw spring-boot:build-image # For maven build system

Der obige Befehl generiert ein Bild mit dem Standardnamen {PROJECT_NAME}:${PROJECT_VERSION}. Wenn Sie den Namen des generierten Bildes konfigurieren möchten, können Sie die folgenden Schritte ausführen:

Konfigurieren Sie den Bildnamen für das Gradle-Build-System

Wir können die bootBuildImage-Aufgabe so konfigurieren, dass sie den Namen des Bildes festlegt:

// For build.gradle.kts
val imagePrefix = "javarush"
val dockerImageName = "docker-example"
tasks.named("bootBuildImage") {
   imageName.set("${imagePrefix}/${dockerImageName}:${version}")
}

// For build.gradle
def imagePrefix = "javarush"
def dockerImageName = "docker-example"
tasks.named("bootBuildImage") {
   imageName = "${imagePrefix}/${dockerImageName}:${version}"
}

Konfigurieren Sie den Image-Namen für das Maven-Build-System

Wir können das Spring-Boot-Maven-Plugin so konfigurieren, dass es einen anderen Bildnamen verwendet, etwa so:

   javarush


...


    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
                
                    
                        ${imagePrefix}/${project.artifactId}:${project.version}
                    
                
            
        
    

Konfigurieren Sie den Bildnamen, während Sie den Befehl ausführen

Wir können sogar den Namen des Bildes definieren, während wir den Befehl zum Erstellen des Bildes ausführen.

./gradlew bootBuildImage --imageName=javarush/docker-example:1.0.0 # For grade build system

./mvnw spring-boot:build-image -Dspring-boot.build-image.imageName=javarush/docker-example:1.0.0 # For maven build system

Sie können sich die Dokumentation ansehen, um das Gradle- oder Maven-Plugin weiter zu konfigurieren.
Dies ist meine bevorzugte Methode zum Erstellen eines Docker-Images für jede Spring Boot-Anwendung.

Docker-Container ausführen

Sobald Sie ein Docker-Image erstellt haben, müssen Sie sicherstellen, dass es wie erwartet funktioniert. Nachdem Sie sichergestellt haben, dass das Image erstellt wurde, können Sie es direkt mit dem Docker-Run-Befehl ausführen. Zum Beispiel,

docker run -p "8080:8080" {IMAGE_NAME}

Aber so werden Bilder in Produktionsanwendungen nicht verwendet. Docker Compose wird zum Ausführen und Verwalten mehrerer Docker-Images verwendet.

Abschluss

In diesem Blog haben wir gesehen, wie man Docker-Images für Spring Boot-Anwendungen mit verschiedenen Methoden erstellt. Die Fähigkeit, Docker-Images für Ihre Apps zu erstellen, ist ein Muss, da das Image geliefert wird. Vielen Dank, dass Sie den Artikel bis zum Ende gelesen haben. Ich schätze es. Ich werde dich im nächsten treffen. Wie immer sind alle Rückmeldungen und Vorschläge willkommen.