[JAVA] Cachez les fichiers dépendants de Gradle pour accélérer la construction du docker

Abstrait

• En exécutant gradlew build avec uniquement les fichiers liés à Gradle COPY, créez une couche pour le cache où les fichiers dépendants sont téléchargés.
• Le temps de construction de l'image Docker a été réduit d'environ 70% (* Il existe des différences en fonction de l'environnement et du projet.)

Motivation

Le temps de création de l'image Docker pour l'application Spring Boot a pris plus de 5 minutes. Pour cette raison, la création et le déploiement dans l'environnement d'inspection prennent du temps. Il y avait un problème en raison du fait que les essais et erreurs ont pris du temps, ce qui ne peut être fait que dans l'environnement d'inspection.

Sample Dockerfile

FROM openjdk:11.0.8-jre-slim as builder

WORKDIR /app

# build.Ajoutez uniquement les fichiers qui dépendent de gradle,
#Gradle inactif pour mettre en cache les fichiers dépendants
COPY *.gradle gradle.* gradlew /app/
COPY gradle/ /app/gradle/
RUN ./gradlew build -x test --parallel --continue > /dev/null 2>&1 || true

#Incorporer et créer des modifications de code après les lignes suivantes
COPY . /app
RUN ./gradlew build -x test --parallel

FROM openjdk:11.0.8-jre-slim

COPY --from=builder /app/build/libs/app.jar /app/app.jar
CMD ["java", "-jar", "/app/app.jar"]

Conseils: les générations en plusieurs étapes sont utilisées pour séparer le conteneur de génération et le conteneur d'exécution.

Explication détaillée

Exemple général de Dockerfile

Je pense que le Dockerfile qui fait une construction Gradle commune est le suivant.

FROM openjdk:11.0.8-jre-slim as builder
WORKDIR /app
COPY . /app
RUN ./gradlew build -x test --parallel

Le problème avec ce Dockerfile est qu'il prend beaucoup de temps à construire car les binaires gradle et les fichiers dépendants sont téléchargés à chaque fois que vous créez. Cette fois, nous allons accélérer en mettant en cache le téléchargement de ce gradle binaire et des fichiers dépendants dans la couche d'image.

Il n'y a pas de commande pour télécharger les fichiers dépendants dans Gradle

Malheureusement, il n'existe aucune commande Gradle qui télécharge uniquement les binaires et les fichiers dépendants. Cependant, le téléchargement est effectué au début de l'exécution de la génération. Par conséquent, même si la génération échoue, le pré-téléchargement est effectué en désactivant la génération.

$ ./gradlew build --continue > /dev/null 2>&1 || true

En ajoutant l'option --continue, même une compilation avec plusieurs projets peut être exécutée jusqu'à la fin et les fichiers dépendants peuvent être téléchargés.

Caractéristiques du cache de la commande COPY

La commande COPY vérifie si le cache peut être utilisé en fonction de la somme de contrôle du fichier. (* Ce n'est pas la dernière date de mise à jour ou la date et l'heure d'accès) Par conséquent, vous pouvez créer une couche qui télécharge les fichiers dépendants en «COPY» les fichiers minimum requis pour la construction gradle et la construction inactive. Puisque build.gradle etc. sont rarement modifiés, le cache peut être utilisé dans de nombreuses versions, et le temps de construction peut être réduit.

COPY *.gradle gradle.* gradlew /app/
COPY gradle/ /app/gradle/

Effet de réduction

En utilisant le cache de fichiers dépendant de Gradle ci-dessus, vous pouvez réduire le temps de création d'image de Docker. Concernant l'effet de réduction, cela dépend de l'environnement et du projet Java, mais je partagerai le résultat de mon application.

Avant application: 4min 56sec Après application: 1min 42sec

En appliquant cette méthode, nous avons pu réduire le temps de construction d'environ 70%.

finalement

Nous espérons que la méthode ci-dessus réduira autant que possible le temps de création d'image de Docker en utilisant Gradle dans le monde. Si vous trouvez des erreurs dans la description, veuillez nous en informer dans les commentaires.