Comment déployer le projet SpringBoot à l'aide de Docker

Construisez d'abord un projet Spring Boot simple, puis ajoutez le support Docker au projet et enfin déployez le projet.

Un simple projet Spring Boot

Dans pom.xml, utilisez les dépendances liées à Spring Boot 2.0

<parent>
 <groupid>org.springframework.boot</groupid>
 <artifactid>spring-boot-starter-parent</artifactid>
 <version>2.0.0.release</version>
</parent>

Ajoutez des dépendances Web et de test

<dependencies>
   <dependency>
 <groupid>org.springframework.boot</groupid>
 <artifactid>spring-boot-starter-web</artifactid>
  </dependency>
 <dependency>
 <groupid>org.springframework.boot</groupid>
 <artifactid>spring-boot-starter-test</artifactid>
 <scope>test</scope>
 </dependency>
</dependencies>

Créez un dockercontroller, dans lequel se trouve une méthode index(), lors de l'accès Retour : bonjour docker !

@restcontroller
public class dockercontroller {
 
  @requestmapping("/")
  public string index() {
    return "hello docker!";
  }
}

Classe de démarrage

@springbootapplication
public class dockerapplication {
 
 public static void main(string[] args) {
 springapplication.run(dockerapplication.class, args);
 }
}

Démarrez le projet après l'avoir ajouté. Après un démarrage réussi, l'accès du navigateur : http://localhost:8080/, la page renvoie : bonjour docker !, indiquant que le spring boot. la configuration du projet est normale.

Le projet Spring Boot ajoute la prise en charge de Docker

Ajoutez le nom de l'image Docker dans pom Ce document décrit comment créer l'image.

<properties>
 <docker.image.prefix>springboot</docker.image.prefix>
</properties>

Ce fichier docker est très simple. Construisez l'environnement de base jdk et ajoutez le pot Spring Boot à l'image. Une brève explication :

from signifie utiliser l'environnement jdk8 comme image de base. il sera téléchargé depuis dockerhub

• volume, le volume pointe vers un répertoire /tmp Puisque Spring Boot utilise le conteneur Tomcat intégré, Tomcat utilise /tmp comme répertoire de travail par défaut. L'effet de cette commande est : créez un fichier temporaire dans le répertoire /var/lib/docker de l'hôte et liez-le au répertoire /tmp du conteneur

• add, copiez le fichier et renommez-le

• point d'entrée, afin de raccourcir le temps de démarrage de Tomcat, ajoutez la propriété système de java.security.egd pour pointer vers /dev/urandom comme point d'entrée

• De cette façon, le projet Spring Boot ajoute une dépendance Docker.

Créer un environnement de packaging

Nous avons besoin d'un environnement Docker pour empaqueter le projet Spring Boot. Il est difficile de créer un environnement Docker sous Windows, j'utiliserai donc Centos 7 comme exemple ici.

Installer l'environnement Docker

Installation

<build>
 <plugins>
 <plugin>
  <groupid>org.springframework.boot</groupid>
  <artifactid>spring-boot-maven-plugin</artifactid>
 </plugin>
 <!-- docker maven plugin -->
 <plugin>
  <groupid>com.spotify</groupid>
  <artifactid>docker-maven-plugin</artifactid>
  <version>1.0.0</version>
  <configuration>
  <imagename>${docker.image.prefix}/${project.artifactid}</imagename>
  <dockerdirectory>src/main/docker</dockerdirectory>
  <resources>
   <resource>
   <targetpath>/</targetpath>
   <directory>${project.build.directory}</directory>
   <include>${project.build.finalname}.jar</include>
   </resource>
  </resources>
  </configuration>
 </plugin>
 <!-- docker maven plugin -->
 </plugins>
</build>

Une fois l'installation terminée, utilisez la commande suivante pour démarrer le service Docker et le configurer pour qu'il démarre au démarrage :

from openjdk:8-jdk-alpine
volume /tmp
add spring-boot-docker-1.0.jar app.jar
entrypoint ["java","-djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

Utiliser l'accélérateur Docker China

yum install docker

Redémarrer Docker

service docker start
chkconfig docker on
 
#lctt 译注：此处采用了旧式的 sysv 语法，如采用centos 7中支持的新式 systemd 语法，如下：
systemctl start docker.service
systemctl enable docker.service

Entrez la version du docker et si les informations de version sont renvoyées, l'installation est normale.

Installez jdk

vi /etc/docker/daemon.json
 
#添加后：
{
  "registry-mirrors": ["https://registry.docker-cn.com"],
  "live-restore": true
}

Configurez les variables d'environnement Ouvrez vim /etc/profile et ajoutez du contenu

systemctl restart docker

Une fois la modification terminée, rendez-la effective

yum -y install java-1.8.0-openjdk*

Entrez java -version pour renvoyer les informations de version et l'installation est normal.

Installez maven

Télécharger :

export java_home=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.161-0.b14.el7_4.x86_64
export path=$path:$java_home/bin

Modifiez les variables d'environnement et ajoutez les lignes suivantes dans /etc/profile

source /etc/profile

N'oubliez pas d'exécuter la source /etc/profile pour que les variables d'environnement prennent effet.

Entrez mvn -version et les informations de version seront renvoyées, l'installation est alors normale.

L'ensemble de l'environnement de build est maintenant configuré.

Utilisez Docker pour déployer le projet Spring Boot

Copiez le projet spring-boot-docker sur le serveur et entrez le chemin du projet pour les tests d'empaquetage.

## 解压
tar vxf apache-maven-3.5.2-bin.tar.gz
## 移动
mv apache-maven-3.5.2 /usr/local/maven3

Après avoir vu le journal de démarrage de Spring Boot, il montre qu'il n'y a aucun problème avec la configuration de l'environnement. Ensuite, nous utilisons dockerfile pour créer l'image.

maven_home=/usr/local/maven3
export maven_home
export path=${path}:${maven_home}/bin

La première build peut être un peu lente. Lorsque vous voyez le contenu suivant, la build est réussie :

#打包
mvn package
#启动
java -jar target/spring-boot-docker-1.0.jar

Utilisez la commande docker images pour afficher l'image construite :

mvn package docker:build

springboot/spring-boot-docker est quoi. nous avons construit l'image, l'étape suivante consiste à exécuter l'image

...
step 1 : from openjdk:8-jdk-alpine
 ---> 224765a6bdbe
step 2 : volume /tmp
 ---> using cache
 ---> b4e86cc8654e
step 3 : add spring-boot-docker-1.0.jar app.jar
 ---> a20fe75963ab
removing intermediate container 593ee5e1ea51
step 4 : entrypoint java -djava.security.egd=file:/dev/./urandom -jar /app.jar
 ---> running in 85d558a10cd4
 ---> 7102f08b5e95
removing intermediate container 85d558a10cd4
successfully built 7102f08b5e95
[info] built springboot/spring-boot-docker
[info] ------------------------------------------------------------------------
[info] build success
[info] ------------------------------------------------------------------------
[info] total time: 54.346 s
[info] finished at: 2018-03-13t16:20:15+08:00
[info] final memory: 42m/182m
[info] ------------------------------------------------------------------------

Une fois le démarrage terminé, nous utilisons docker ps pour afficher l'image en cours d'exécution :

docker images
repository           tag         image id      created       size
springboot/spring-boot-docker  latest       99ce9468da74    6 seconds ago    117.5 mb

Vous pouvez voir que le conteneur que nous avons construit est en cours d'exécution, visitez le navigateur : http ://192.168.0.x:8080/, renvoie

docker run -p 8080:8080 -t springboot/spring-boot-docker

indiquant que le projet Spring Boot a été déployé avec succès à l'aide de Docker !

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!