Contexte

Je l'ai écrit pour les personnes qui peuvent créer des applications Spring à l'aide d'un IDE textuel, mais ne connaissent pas Docker ou jar.

Pour le moment, je voulais m'habituer à l'environnement Docker + Spring localement, donc un mémorandum d'apprentissage.

supposition

Environnement d'exécution

macOS Catalina 10.15.6

Quoi utiliser (en gros)

Application créée avec Spring-Boot (en supposant qu'elle fonctionne sur IDE, version: 2.3.3)
Gradle (Seule la partie de génération de jar est liée, donc si vous utilisez Maven, veuillez vérifier la commande de construction séparément)
Docker (version: 19.03.13)

Structure du répertoire des applications

.
├── HELP.md
├── build
├── build.gradle //Paramètres de construction
├── gradle
├── gradlew
├── gradlew.bat
├── settings.gradle
└── src //Source écrite avec beaucoup de soin

Je l'ai généré à partir de l'initialiseur Spring, mais il devrait ressembler à ce qui précède. ..

procédure

Aperçu

Générez un fichier jar à partir de l'application créée.
Préparez un Dockerfile.
Démarrez Docker.

fin. (Fonctionne sur le conteneur Docker !!)

Détails

1. Générez un fichier jar à partir de l'application créée.

Ajout de paramètres pour générer le fichier jar dans build.gradle


//↑ Omis, les dépendances sont lisses ...//

//Supplémentaire ↓//
def springBootApplicationName = 'test-build' //Variable qui définit le nom du fichier jar à générer (il n'est pas nécessaire de le transformer en une variable distincte)
def applicationVersion = project.properties['release.version'] //Variable qui définit la version (elle ne doit pas être transformée en une variable distincte)

bootJar {
    baseName = springBootApplicationName //Spécifiez le nom du fichier jar à générer
    version = applicationVersion //Spécifiez la version (je n'ai pas vérifié les détails, mais ce n'est pas obligatoire)
}

Accédez au répertoire de l'application sur le terminal et appuyez sur la commande suivante

$ gradle build

Confirmez que le fichier jar est généré sous `. / Build / libs`

$ tree ./build/libs
./build/libs
└── test-build.jar

2. Préparez un Dockerfile.

Créez un fichier nommé `Dockerfile` dans le répertoire supérieur de votre application. (Aucune extension requise)

.
├── Dockerfile // New!!
├── HELP.md
├── build
├── build.gradle
├── docker-compose.yaml
├── gradle
├── gradlew
├── gradlew.bat
├── settings.gradle
└── src

Décrivez ce qui suit dans le Dockerfile

#Spécifiez l'image utilisée par Docker Hub. Spécifiez le JDK pour exécuter Java 11
#(Bien qu'il existe un openJDK officiel, je l'ai créé en supposant qu'il sera déployé sur AWS, donc je spécifie en quelque sorte celui fourni par AWS ici)
FROM amazoncorretto:11 

#Définition de variable qui stocke le chemin du répertoire où se trouve le fichier jar précédemment généré (ici, spécifiez la valeur de la commande)
ARG JAR_FILE

#Copiez le fichier jar dans le conteneur.(app.jar spécifie l'emplacement dans le conteneur (n'importe quel emplacement))
COPY ${JAR_FILE} app.jar

#Définissez la commande à exécuter lorsque ce conteneur est exécuté (ici, le jar copié est exécuté)
ENTRYPOINT ["java","-jar","/app.jar","--spring.profiles.active=docker"]

3. Démarrez Docker.

Installez `Docker` s'il n'est pas installé

Reportez-vous à l'article ici

Accédez au répertoire de l'application sur le terminal et appuyez sur la commande suivante. (Génération d'image Docker)

docker build --build-arg JAR_FILE=build/libs/exercise-manage-backend.jar -t springio/gs-spring-boot-docker .

Explication partielle des options:

Spécifiez la valeur de la variable définie sur le Dockerfile.

--build-arg JAR_FILE=build/libs/exercise-manage-backend.jar

Le nom donné à l'image générée (facultatif, je citerai celui de l'article mentionné ici tel quel)

-t springio/gs-spring-boot-docker

Après avoir généré l'image, appuyez sur la commande suivante. (Démarrage de l'image Docker)

Remarque: les options telles que -p doivent être définies juste à droite de run pour être définies. (J'étais fou ici car il n'y avait pas d'article de référence ... Est-ce du bon sens dans la zone de commandement ...?)

docker run -p 8080:8080 --name spring-test --rm  springio/gs-spring-boot-docker

Explication partielle des options:

Mappez le port sur le conteneur (à gauche) et le port sur l'hôte d'exécution (à droite). S'il n'est pas spécifié dans application.properties, il doit être démarré sur 8080, associez-le donc au port 8080 local.

-p 8080:8080

Je pense que le journal de démarrage Spring que vous connaissez dans l'EDI coulera, donc après avoir confirmé qu'il a démarré avec succès, accédez à localhost: 8080

→ Vous pouvez vous connecter à l'application sur le conteneur! !!

La méthode d'arrêt ou de suppression de l'image est omise.

A part: Comment se connecter à DB sur localhost

Défini comme host.docker.internal: (numéro de port) (si localhost: (numéro de port) reste, il ne se connectera pas)
Exemple: jdbc: mysql: //host.docker.internal: 3306 / xxx

Postscript

Si vous regardez cela, vous pouvez exécuter Spring avec Docker pour le moment ...! Je l'ai écrit dans le but d'un article qui peut être dans un tel état. Des explications détaillées telles que le concept de Docker et les détails des commandes ont été écrites par divers experts, je les omettrai donc ici.

Docker Je viens de le toucher, alors je vous serais reconnaissant de bien vouloir souligner les points que vous ne comprenez pas.

Un gars qui ne pouvait exécuter que des applications Spring sur l'EDI a essayé de l'exécuter sur Docker