Création d'une image Docker de l'application Spring Boot à l'aide de Buildpacks

Introduction

Vous avez créé une application Spring Boot. Cela fonctionne très bien sur votre ordinateur local et vous devez maintenant déployer l'application ailleurs. Sur certaines plateformes, vous pouvez directement soumettre le fichier jar et il sera déployé. À certains endroits, vous pouvez démarrer une machine virtuelle, y télécharger le code source, le créer et l'exécuter. Mais la plupart du temps, vous devrez déployer l’application à l’aide de conteneurs. La plupart du temps, Docker est utilisé pour créer et exécuter l’image dans un conteneur. De plus, lorsque vous téléchargez le fichier jar sur certaines plates-formes, l'application est exécutée dans un conteneur sous le capot.

Donc, dans ce blog, nous verrons 3 façons différentes de créer une image Docker pour l'application Spring Boot donnée. Commençons :

Image du conteneur de base

La manière naïve et insuffisante de créer l'image Docker pour n'importe quelle application consiste à utiliser un simple Dockerfile qui copie le fichier jar à l'intérieur de l'image et à l'exécuter à l'aide de la commande java -jar.

Créer un fichier Docker

Voici le Dockerfile que vous pouvez mettre à la racine du projet :

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

ARG JAR_FILE

COPY ${JAR_FILE} application.jar

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

Nous avons spécifié un argument JAR_FILE qui est l'emplacement du fichier jar à utiliser.

Création d'une image Docker

Après avoir créé le Dockerfile ci-dessus, les étapes ci-dessous sont utilisées pour créer l'image Docker :

1. Construisez le fichier jar pour le projet Spring Boot :
   

   ./gradlew bootJar # For Gradle build system
   

   OU
   

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

2. Utilisez le Dockerfile pour créer l'image Docker en utilisant le dernier fichier jar. Dans la commande ci-dessous, remplacez {IMAGE_NAME} par le nom de l'image requis et {JAR_FILE} par le chemin d'accès au fichier jar généré. Le nom de l'image contient également une balise, comme - mycompany/product-service:0.0.1-SNAPSHOT:
   

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

3. Vérifiez si l'image Docker est créée à l'aide de la commande suivante. Vous devriez pouvoir voir l'image avec le nom spécifié dans la commande ci-dessus :
   

   docker images
   

Image de conteneur efficace à l'aide d'un pot en couches

Bien qu'il soit possible et facile d'empaqueter un uber jar Spring Boot en tant qu'image Docker (comme mentionné dans la méthode précédente), il existe de nombreux inconvénients à copier et à exécuter le fat jar tel quel dans l'image Docker. Par exemple,

• Il y a des frais supplémentaires lors de l'exécution d'Uber Jar sans le déballer.
• Mettre le code de l'application et toutes ses dépendances dans une seule couche n'est pas optimal.

Comme nous compilons notre code plus souvent que de mettre à jour la version Spring Boot, il est préférable de séparer un peu plus les choses. Si nous plaçons ces fichiers jar (qui sont rarement modifiés) dans la couche avant la couche d'application, alors Docker doit souvent modifier uniquement la couche inférieure et peut récupérer le reste de son cache.

Activer le pot en couches

Pour créer une image Docker en couches, nous devons d'abord créer un pot en couches. De nos jours, il est activé par défaut dans Gradle et Maven. Vous pouvez activer ou désactiver le comportement du pot en couches à l'aide du paramètre suivant :

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

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

7a7963d93b467c9ab002af7a44e64bd4
c70346ba2d7be186a93fef826469bd2f
   5ac54a929980b32fdd2e48b6a8da067c
      c4222ff3007372f15ec728b963e717b6
         33ca7039399a4759a8764ea38765dd46
            05a8acc5c31084a4f61ade01873802caorg.springframework.boot192ca2f7b8c770b01c8f81e6bdd5b947
            9bc4cbb67f66e148869423c0d27e5f90spring-boot-maven-pluginb68fb17cb904a46b73e6272850323873
            f9d9f4a8f32d97f3ef0c10742ed31240
               e72a6d14eb9b15c1c12186917135155b
                  d79c9ed277a80783d30ca709c63bc2d1true1d1b3b9680fd03597e1ed3fa2b627c20
               98a78221d1c969529e0b9f39a24b39b0
            4b1b9d85fe86862ae3eab7e2045cf8a0
         9424ec9162a9b85f34067d0c54f34b32
      f3567a435ac6132b26525998d793443b
   f82c24fb6fac67972f6e79c18ccef56a
1755c7176d4002e2a322de4f48c796fa

Vous pouvez même régler la façon dont les calques sont créés. Voir la documentation pour la configuration Gradle ou Maven.

Créer un fichier Docker

Vous trouverez ci-dessous le Dockerfile, qui peut être utilisé pour tirer parti du pot en couches et pour créer une image Docker en couches de l'application Spring Boot.

# 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"]

Création d'une image Docker

Les étapes pour créer l'image Docker en couches sont les mêmes que pour créer une image Docker de base. Veuillez vous y référer.

Packs de build natifs du cloud

Et si je vous dis que vous pouvez créer une image Docker sans créer de fichier Docker ? Nous pouvons créer des images Docker directement à partir du plugin Gralde ou Maven à l'aide de Cloud Native Buildpacks. Certaines plates-formes (comme Heroku ou Cloud Foundry) utilisent des Buildpacks pour convertir les fichiers jar fournis en images exécutables.

Spring Boot inclut la prise en charge du buildpack directement pour Maven et Gradle. Nous n'avons pas besoin d'inclure de plugins supplémentaires. Exécutez simplement la commande ci-dessous :

./gradlew bootBuildImage # For gradle build system

OU

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

La commande ci-dessus génère une image avec le nom par défaut {PROJECT_NAME} :${PROJECT_VERSION}. Si vous souhaitez configurer le nom de l'image générée, vous pouvez suivre les étapes ci-dessous :

Configurer le nom de l'image pour le système de build Gradle

Nous pouvons configurer la tâche bootBuildImage pour définir le nom de l'image, comme ceci :

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

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

Configurer le nom de l'image pour le système de build Maven

Nous pouvons configurer spring-boot-maven-plugin pour utiliser un autre nom d'image, comme ceci :

a01741acb88936e4cea4237317380dd9
   d025b153d4d19d25710ee358f3c66eafjavarush515db9ab99a6918e33f7eeaddd64c8cf
86cd8b5c0fbd401fb69261955cf13796

...

c70346ba2d7be186a93fef826469bd2f
    5ac54a929980b32fdd2e48b6a8da067c
        c4222ff3007372f15ec728b963e717b6
            33ca7039399a4759a8764ea38765dd46
                05a8acc5c31084a4f61ade01873802caorg.springframework.boot192ca2f7b8c770b01c8f81e6bdd5b947
                9bc4cbb67f66e148869423c0d27e5f90spring-boot-maven-pluginb68fb17cb904a46b73e6272850323873
                f9d9f4a8f32d97f3ef0c10742ed31240
                    dc0870658837139040642baa5555a380
                        8a11bc632ea32a57b3e3693c7987c420${imagePrefix}/${project.artifactId}:${project.version}df406f776eecbaf16b62325323196f14
                    f8e950ebc6c1ea27f76cf997b9216fe6
                4b1b9d85fe86862ae3eab7e2045cf8a0
            9424ec9162a9b85f34067d0c54f34b32
        f3567a435ac6132b26525998d793443b
    f82c24fb6fac67972f6e79c18ccef56a
1755c7176d4002e2a322de4f48c796fa

Configurer le nom de l'image lors de l'exécution de la commande

Nous pouvons même définir le nom de l'image lors de l'exécution de la commande pour construire l'image.

./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

You can see the documentation to further configure Gradle or Maven plugin.
This is my go-to method to create a Docker image for any Spring Boot application.

Running Docker Container

Once you create a docker image, you need to make sure that it works as expected. After you make sure that the image is created, you can directly run it using the docker run command. For example,

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

But, this is not how images are used in production applications. Docker Compose is used to run and manage multiple docker images.

Conclusion

In this blog, we have seen how to build Docker images for Spring Boot applications using different methods. Being able to build docker images for your apps is a must skill to know because the image is what gets delivered. Thanks for reading the article till the end. I appreciate it. I will meet you in the next one. As always, all feedback and suggestions are welcome.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!