How to run Spring Boot application in Docker

In the past few days, I have studied how to run spring boot applications in docker. Previously, there was a maven plug-in that could directly create a docker folder in src/main and a new Dockerfile file. After compiling and packaging, you can directly run the docker plug-in, which is equivalent to executing docker build . It will directly build the current application into a mirror and then run it, which is very convenient. However, after personal testing, I found that this plug-in is not stable, and the docker folder may not be put into the target folder every time, so this plug-in is not very useful when executed.

Therefore, when I later built the spring boot application into a mirror, I no longer used the provided docker maven plug-in, but created a new Dockerfile file in the root directory of the current project. After the application was written, I manually executed the command to build the application into a mirror, as follows.

Springboot application

pom.xml

In the pom.xml here, you need to specify several repositories and provide several plug-ins, as follows:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>

 <groupId>cn.com</groupId>
 <artifactId>springbootweb</artifactId>
 <version>1.0-SNAPSHOT</version>
 <packaging>jar</packaging>

 <name>spring :: boot :: web</name>

 <parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>1.4.1.RELEASE</version>
  <relativePath/>
 </parent>

 <properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <docker.image.prefix>springio</docker.image.prefix>
  <docker.version>0.3.8</docker.version>
  <java.version>1.8</java.version>
 </properties>

 <dependencies>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
 </dependencies>



 <repositories>
  <repository>
   <id>spring-snapshots</id>
   <url>http://repo.spring.io/snapshot</url>
   <snapshots>
    <enabled>true</enabled>
   </snapshots>
  </repository>
  <repository>
   <id>spring-milestones</id>
   <url>http://repo.spring.io/milestone</url>
   <snapshots>
    <enabled>true</enabled>
   </snapshots>
  </repository>
 </repositories>

 <pluginRepositories>
  <pluginRepository>
   <id>spring-snapshots</id>
   <url>http://repo.spring.io/snapshot</url>
  </pluginRepository>
  <pluginRepository>
   <id>spring-milestones</id>
   <url>http://repo.spring.io/milestone</url>
  </pluginRepository>
 </pluginRepositories>


 <build>
  <plugins>
   <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.2</version>
    <configuration>
     <compilerArgument>-parameters</compilerArgument>
     <source>1.8</source>
     <target>1.8</target>
     <encoding>UTF-8</encoding>
    </configuration>
   </plugin>
   <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.18.1</version>
    <configuration>
     <skipTests>true</skipTests>
    </configuration>
   </plugin>

   <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-resources-plugin</artifactId>
    <version>2.6</version>
    <configuration>
     <encoding>UTF-8</encoding>
    </configuration>
   </plugin>
   <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <!--<version>${spring.boot.version}</version>-->
    <configuration>
     <mainClass>cn.com.SpringBootWebApplication</mainClass>
     <layout>ZIP</layout>
    </configuration>
    <executions>
     <execution>
      <goals>
       <goal>
        repackage
       </goal>
      </goals>
     </execution>
    </executions>
   </plugin>
  </plugins>
 </build>

 <profiles>
  <profile>
   <id>JDK1.8</id>
   <activation>
    <activeByDefault>true</activeByDefault>
   </activation>
   <properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <encoding>UTF-8</encoding>
   </properties>
  </profile>
 </profiles>
</project>

Several warehouse addresses are provided here. The reason is that when the springboot application is put into docker in this article, the source code is directly put in, and then compiled and packaged in it for running. If the warehouse address is not provided to download the jar package, the dependencies will be pulled from the central warehouse, which will be very slow and the pull timeout will occur, resulting in the application being unusable. Therefore, several other warehouse addresses are provided to download dependencies. In addition, there is a plug-in here. After using this plug-in, you can run the application directly in the form of mvn spring-boot:run, so I did not decide to use java -jar xxx.jar to run the application.

Application and controller

This SpringBoot application is quite simple and provides a simple controller with an interface similar to Hello World, as follows:

package cn.com.controllers;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

/**
 * Created by xiaxuan on 16/11/27.
 */
@RestController
public class IndexController {

  @RequestMapping(value = "/index", produces = "application/json;charset=utf-8")
  public Object index() {
    Map<String, Object> result = new HashMap<String, Object>();
    result.put("msg", "hello world");
    return result;
  }
}

Provide a simple helloworl method.

The following is the Application startup class:

packagecn.com;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * Created by xiaxuan on 16/11/27.
 */
@SpringBootApplication
public class SpringBootWebApplication {

  public static void main(String[] args) {
    SpringApplication.run(SpringBootWebApplication.class, args);
  }
}

In a normal spring boot startup, it is quite simple. Just start the SpringBootWebApplication startup class. However, if you run it in a docker container, it is not that simple. Take a look at the Dockerfile file below.

Dockerfile

The Dockerfile file is also relatively simple, as follows:

# base image
FROM java:8

# maintainer
MAINTAINER bingwenwuhen [email protected]

# update packages and install maven

RUN \
 export DEBIAN_FRONTEND=noninteractive && \
 sed -i 's/# \(.*multiverse$\)/\1/g' /etc/apt/sources.list && \
 apt-get update && \
 apt-get -y upgrade && \
 apt-get install -y vim wget curl maven

# attach volumes
VOLUME /vol/development


# create working directory
RUN mkdir -p /vol/development
RUN mkdir -p /vol/development/src
WORKDIR /vol/development

COPY ./src /vol/development/src/
COPY ./pom.xml /vol/development/

# maven exec
CMD ["mvn", "clean", "install", "spring-boot:run"]

The dockerfile uses java8 as the base image, and maven needs to be installed separately in the base image. Because in our dockerfile file, the entire source code is typed into the image, and here only the generated jar is not typed into the image. So this is what I said before that the warehouse needs to be specified in pom.xml. If the warehouse is not specified, when pulling dependencies in the image, dependencies will be pulled from the central warehouse, which will be very slow. I have tried it several times before, and the basic pulling process has timed out and failed, so specify the warehouse here to pull dependencies.

Build the image

Now execute the command in the directory, docker build -t="bingwenwuhen/springboot01" . Build the image as follows:

After mirroring, run
docker run -d --name springboot01 -p 8080:8080 bingwenwuhe/spingboot01
The above command generates a container for running the image, mapping port 8080 and name springboot01.

Now docker logs xxxxx to view the container logs:

Now the container is running.

Request interface

Before requesting the interface, you need to check the IP address of the Docker virtual machine. The IP address of this machine is 192.168.99.100. The command to request the interface is:

curl http://192.168.99.100:8080/index

The response is:

{
  "msg":"hello world"
}

The request is successful. The springboot application is successfully run in docker.

question

When the source code is put into the image and mvn clean install is compiled and run, too many jar packages are downloaded and the waiting time is too long, which can easily lead to interruptions. Therefore, this method of operation is not recommended.
The source code should not be included in the image in essence, only the running jar package needs to be included in the image.

Source code

I uploaded the source code to github, you can download it if you need it.

Source code download

The above is the full content of this article. I hope it will be helpful for everyone’s study. I also hope that everyone will support 123WORDPRESS.COM.

You may also be interested in: