Detailed steps for Spring Boot packaging and uploading to Docker repository

Important note: Before studying this article, you need to have some knowledge about Docker containers, and understand and be proficient in using common Docker operation commands. If you already have some knowledge about Docker containers, let’s get started!

The following are the general steps to complete the function described in the title:

Build a docker image repository

Modify the Spring Boot configuration file to add the docker repository configuration, package, and upload to the docker image repository

Pull the uploaded image file from your own docker image repository and run it

Step 1: Build a private docker image repository

To build a docker image repository, we need to rely on the docker-registry tool. Docker-registry is an official tool that can be used to build a private image repository. This article is based on the official docker-registry v2.x version: https://docs.docker.com/registry/

1. Pull the registry image file

docker pull registry

2. Start the image

$ docker run -d \
    -p 5000:5000 \
    -v /opt/data/registry:/var/lib/registry \
    registry

-d: daemon thread start
-p: port mapping host port: container port
-v: The data volume maps the address directory in the container to the host. /opt/data/registry is the location where the image private warehouse in the host is stored.
registry is the image name

3. Add daemon.json file and warehouse configuration

vim /etc/docker/daemon.json

Add the following configuration:

{
  "registry-mirrors": [
    "https://registry.docker-cn.com"
  ],
  "insecure-registries": [
    "yourip:5000"
  ]
}

Add the insecure-registries node configuration to the original daemon.json file, yourip: fill in your virtual machine ip, save and exit, reload the configuration file and restart docker

systemctl daemon-reload
systemctl restart docker

4. Test uploading the image to your own image repository. We tag an image and upload it to the repository using the docker tag command: docker tag IMAGE[:TAG] [REGISTRY_HOST[:REGISTRY_PORT]/]REPOSITORY[:TAG]

docker tag ubuntu:latest 127.0.0.1:5000/ubuntu:latest

(The image uploaded for the test here does not have to be the same as the one in the article. You can pull a tomcat image and then upload it.) A marked image will be generated at this time

docker image ls
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
ubuntu latest ba5877dc9bec 6 weeks ago 192.7 MB
127.0.0.1:5000/ubuntu:latest latest ba5877dc9bec 6 weeks ago 192.7 MB

Push to private repository

docker push 127.0.0.1:5000/ubuntu:latest

View the image of the private warehouse (in fact, you can go to the directory mounted when starting the warehouse. In this article, you can view the uploaded image file in the host machine /opt/data/registry directory)

curl 127.0.0.1:5000/v2/_catalog

Pull down the private repository image

docker pull 127.0.0.1:5000/ubuntu:latest

If there is no problem in pulling, it means that the mirror repository has been built.

Step 2 Modify the SpringBoot configuration file to add the docker repository configuration, package, and upload to the docker image repository

Before configuring the SpringBoot project, you need to configure the docker container to upload the jar package to the warehouse.

Open the docker remote api and modify the file.

vim /lib/systemd/system/docker.service

Original ExecStart: ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Add **-H tcp://0.0.0.0:2375**

After modification: ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2375 -H fd:// --containerd=/run/containerd/containerd.sock

(If you are using Alibaba Cloud Server, remember to open port 2375 in the access rules!)

Save and exit, reload the configuration and start Docker

systemctl daemon-reload 
systemctl restart docker

Check whether the configuration is successful.

docker -H 127.0.0.1 info

The following output indicates successful configuration:

Client:
Debug Mode: false

Server:
Containers: 5
Running: 1
Paused: 0
Stopped: 4
Images: 6
Server Version: 19.03.3
Storage Driver: overlay2
.......

Configure the springboot project and add the packaging configuration to the pom file as follows

<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>docker-maven-plugin</artifactId>
    <version>1.1.0</version>
    <executions>
        <execution>
            <id>build-image</id>
            <phase>package</phase>
            <goals>
                <goal>build</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <imageName>jenkins_test/${project.artifactId}:${project.version}</imageName>
        <dockerHost>http://yourip:2375</dockerHost>
        <baseImage>java:8</baseImage>
        <entryPoint>["java", "-jar","/${project.build.finalName}.jar"]
        </entryPoint>
        <resources>
            <resource>
                <targetPath>/</targetPath>
                <directory>${project.build.directory}</directory>
                <include>${project.build.finalName}.jar</include>
            </resource>
        </resources>
    </configuration>
</plugin>

• executions.execution.phase: This is where the Docker image is built when Maven packages the application.
• imageName: used to specify the image name, jenkins_test is the warehouse name, and {project.version} is the image version number;
• dockerHost: the docker server address to which the package is uploaded;
• baseImage: the base image that the application depends on, here is java;
• entryPoint: The command executed when the Docker container is started;
• resources.resource.targetPath: copy the packaged resource files to this directory;
• resources.resource.directory: the directory where the files to be copied are located. The application jar package packaged by Maven is saved in the target directory;
• resources.resource.include: files that need to be copied, packaged application jar package.

After configuring the above content, you can package it (normal springboot maven packaging, or idea mavenproject install)

After the packaging is successfully completed, return to the docker container to view the image warehouse

curl 127.0.0.1:5000/v2/_catalog

After confirming the existence, pull down the uploaded image, and check the image list after the pull is successful

docker images

Display as shown:

This means that this set of operations is successful. The first packaging may be slow because Docker needs to pull the java:8 base image.

Let's start this image.

docker run -p 8080:8080 imageid

-p: port mapping

The startup is successful as shown below:

Because the server.port configured in the application.yml file of the springboot project is 8080. When starting, you need to map 8080:8080. The first 8080 is the port of the host machine and the second 8080 is the port of the container.

So far, everything that needs to be implemented in this article has been implemented. Keep reading for more Easter eggs! ! ! !

There is a log configuration in the springboot project as follows

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
    <!--Define the storage address of the log file. Do not use relative paths in the LogBack configuration.-->
    <property name="LOG_HOME" value="/home/logs" />
    <!-- Console Output -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--Formatted output: %d indicates date, %thread indicates thread name, %-5level: level is displayed 5 characters wide from the left %msg: log message, %n is line break -->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>
    <!-- Generate log files every day -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--Log file output file name-->
            <FileNamePattern>${LOG_HOME}/TestWeb.log.%d{yyyy-MM-dd}.log</FileNamePattern>
            <!--Log file retention days-->
            <MaxHistory>30</MaxHistory>
        </rollingPolicy>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--Formatted output: %d indicates date, %thread indicates thread name, %-5level: level is displayed 5 characters wide from the left %msg: log message, %n is line break -->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
        <!--Maximum log file size-->
        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
            <MaxFileSize>10MB</MaxFileSize>
        </triggeringPolicy>
    </appender>

    <!-- Log output level -->
    <root level="info">
        <appender-ref ref="STDOUT" />
        <appender-ref ref="FILE" />
    </root>
</configuration>

We need to pay attention to the save address of the logs file configured for this node

If we follow the traditional jar package deployment method, the log file should be in /home/logs of the host machine. But now we find that there is no such directory. So where is the problem? Where are the log files output? ? Let's try entering the started springboot container and interactively enter an already running container

docker exec -it containerid bash 

We can see that there is a home directory in it. If we enter the directory one by one, we will find that the log file is here!

Think about it, didn’t we use the data volume command before? Can we map the path in the container to the virtual machine? Give it a try! Stop the started container (let’s delete it directly)

docker stop containerid
docker rm containerid

Restart the container

docker run -d -p 8080:8080 -v /home/logs:/home/logs imageid

This time we added a -d to the command, which means the daemon thread is started (running in the background). Use the following command to view the started container log

docker logs -f containerID 

As you can see, the startup is successful, so it stands to reason that locback.xml will output our log file in the /home/logs directory of the host we mapped. Let's take a look and enter a series of commands, and you can see that the log file is really here!

This is the end of this article about the detailed steps of Spring Boot packaging and uploading to the Docker repository. For more related Spring Boot packaging and uploading content, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope you will support 123WORDPRESS.COM in the future!