docker-maven-plugin packages the image and uploads it to a private warehouse

1. Introduction to docker-maven-plugin

In our continuous integration process, project engineering generally uses Maven to compile and package, and then generate images. By putting the images online, we can greatly improve the online efficiency, and at the same time, we can quickly and dynamically expand the capacity and quickly roll back, which is really convenient. The docker-maven-plugin plugin is designed to help us automatically generate images and push them to the warehouse through simple configuration in Maven projects.

2. Environment and software preparation

In this demonstration environment, I operated on my local Mac OX. The following are the installed software and versions:

• Docker: version 17.03.1-ce
• Maven: version 3.3.9
• Java: version 1.8.0_91
• docker-maven-plugin:1.0.0

Note: Here we want to test the Java Maven project using the docker-maven plug-in to build images, upload images, and other operations, so you need to install Docker, Maven, and Java first. The installation process is ignored here.

3. Demo Example

3.1 Configure DOCKER_HOST

The default connection address of the docker-maven-plugin plug-in to the local Docker is localhost:2375, so we need to set the environment variables first.

DOCKER_HOST=tcp://<host>:2375

Note: If the DOCKER_HOST environment variable is not set, you can specify DOCKER_HOST in the command line to execute it. For example, I specify DOCKER_HOST on my local machine: DOCKER_HOST=unix:///var/run/docker.sock mvn clean install docker:build.

3.2 Example of building an image

There are two ways to build an image. The first is to specify the build information in POM, and the second is to use an existing Dockerfile to build it.
The first method supports configuring FROM, ENTRYPOINT, CMD, MAINTAINER and ADD information in POM, without the need to use Dockerfile configuration. However, if you use VOLUME or other commands in Dockerfile, you need to use the second method, create a Dockerfile, and configure dockerDirectory in POM to specify the path.

Here we take a Java Maven project mavendemo as an example to demonstrate.

3.2.1 Specify build information to build in POM

<build>
    <plugins>
        <plugin>
            <groupId>com.spotify</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <version>1.0.0</version>
            <configuration>
                <imageName>mavendemo</imageName>
                <baseImage>java</baseImage>
                <maintainer>docker_maven [email protected]</maintainer>
                <workdir>/ROOT</workdir>
                <cmd>["java", "-version"]</cmd>
                <entryPoint>["java", "-jar", "${project.build.finalName}.jar"]</entryPoint>
                <!-- Here is the configuration for copying the jar package to the specified directory of the docker container-->
                <resources>
                    <resource>
                        <targetPath>/ROOT</targetPath>
                        <directory>${project.build.directory}</directory>
                        <include>${project.build.finalName}.jar</include>
                    </resource>
                </resources>
            </configuration>
        </plugin>
    </plugins>
</build>

3.2.2 Build using Dockerfile

pom.xml configuration

<build>
    <plugins>
         <plugin>
            <groupId>com.spotify</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <version>1.0.0</version>
            <configuration>
                <imageName>mavendemo</imageName>
                <dockerDirectory>${basedir}/docker</dockerDirectory> <!-- Specify the Dockerfile path -->
                <!-- Here is to copy the jar package to the specified directory configuration of the docker container, which can also be written to the Dokokerfile-->
                <resources>
                    <resource>
                        <targetPath>/ROOT</targetPath>
                        <directory>${project.build.directory}</directory>
                        <include>${project.build.finalName}.jar</include>
                    </resource>
                </resources>
            </configuration>
        </plugin>   
    </plugins>
</build>
 
${basedir}/docker/Dockerfile configuration FROM java
MAINTAINER docker_maven [email protected]
WORKDIR /ROOT
CMD ["java", "-version"]
ENTRYPOINT ["java", "-jar", "${project.build.finalName}.jar"]

The above two methods of executing docker:build have the same effect. The execution output process is as follows:

[INFO] --- docker-maven-plugin:1.0.0:build (default-cli) @ mavenDemo ---
[INFO] Building image mavendemo
Step 1/5: FROM java
---> d23bdf5b1b1b
Step 2/5: MAINTAINER docker_maven [email protected]
---> Using cache
---> 2faf180d4a50
Step 3/5: WORKDIR /ROOT
---> Using cache
---> 862210f7956a
Step 4/5 : ENTRYPOINT java -jar mavenDemo.jar
---> Running in 96bbe83de6ec
---> c29009c88993
Removing intermediate container 96bbe83de6ec
Step 5/5 : CMD java -version
---> Running in f69b8d2a75b1
---> bc8d54014325
Removing intermediate container f69b8d2a75b1
Successfully built bc8d54014325

After the execution is complete, use docker images to view the generated image:

REPOSITORY TAG IMAGE ID CREATED SIZE
mavendemo latest 333b429536b2 38 minutes ago 643 MB

3.3 Executing commands

mvn clean package docker:build only executes the build operation

mvn clean package docker:build -DpushImage executes the build and pushes the image after completion

mvn clean package docker:build -DpushImageTag executes the build and pushes the image of the specified tag

Note: At least one imageTag must be specified here, which can be configured in the POM or specified on the command line. The command line is specified as follows: mvn clean package docker:build -DpushImageTags -DdockerImageTags=imageTag_1 -DdockerImageTags=imageTag_2, and the configuration specified in the POM file is as follows:

<build>
  <plugins>
    ...
    <plugin>
      <configuration>
        ...
        <imageTags>
           <imageTag>imageTag_1</imageTag>
           <imageTag>imageTag_2</imageTag>
        </imageTags>
      </configuration>
    </plugin>
    ...
  </plugins>
</build>

3.4 Binding Docker commands to Maven stages

We can bind Docker commands to various Maven stages. We can divide Docker into build, tag, and push, and then bind them to Maven's package and deploy stages respectively. At this time, we only need to execute mvn deploy to complete the entire build, tag, and push operations. When we execute mvn build, only the build and tag operations are completed. In addition, when we want to skip certain steps or only execute a certain step, we do not need to modify the POM file, we only need to specify to skip a certain docker step. For example, when our project has already configured the automation template, but this time we only need to build the image to the local self-test and do not want to execute the push stage, then we need to specify the parameter -DskipDockerPush to skip the push operation.

<build>
    <plugins>
        <plugin>
            <groupId>com.spotify</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <version>1.0.0</version>
            <configuration>
                <imageName>mavendemo</imageName>
                <baseImage>java</baseImage>
                <maintainer>docker_maven [email protected]</maintainer>
                <workdir>/ROOT</workdir>
                <cmd>["java", "-version"]</cmd>
                <entryPoint>["java", "-jar", "${project.build.finalName}.jar"]</entryPoint>
                <resources>
                    <resource>
                        <targetPath>/ROOT</targetPath>
                        <directory>${project.build.directory}</directory>
                        <include>${project.build.finalName}.jar</include>
                    </resource>
                </resources>
            </configuration>
            <executions>
                <execution>
                    <id>build-image</id>
                    <phase>package</phase>
                    <goals>
                        <goal>build</goal>
                    </goals>
                </execution>
                <execution>
                    <id>tag-image</id>
                    <phase>package</phase>
                    <goals>
                        <goal>tag</goal>
                    </goals>
                    <configuration>
                        <image>mavendemo:latest</image>
                        <newName>docker.io/wanyang3/mavendemo:${project.version}</newName>
                    </configuration>
                </execution>
                <execution>
                    <id>push-image</id>
                    <phase>deploy</phase>
                    <goals>
                        <goal>push</goal>
                    </goals>
                    <configuration>
                        <imageName>docker.io/wanyang3/mavendemo:${project.version}</imageName>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

In the above example, when we execute mvn package, the build and tag operations are executed, and when we execute mvn deploy, the build, tag, and push operations are executed. If we want to skip a docker process, we only need to:

• -DskipDockerBuild skips building the image
• -DskipDockerTag skip tag image
• -DskipDockerPush skips pushing the image
• -DskipDocker skips the entire stage

For example, if we want to skip the tag process when executing the package, we need mvn package -DskipDockerTag.

3.5 Using a private Docker repository address

In the actual working environment, we need to push the image to our private Docker repository. It is also very easy to achieve using the docker-maven-plugin plug-in. There are several ways to achieve it:

1. Modify the POM file imageName operation

...
<configuration>
    <imageName>registry.example.com/wanyang3/mavendemo:v1.0.0</imageName>
    ...
</configuration>
...

2. Modify the newName operation in the POM file

...
<configuration>
    <imageName>mavendemo</imageName>
    ...
</configuration>
<execution>
    <id>tag-image</id>
    <phase>package</phase>
    <goals>
        <goal>tag</goal>
    </goals>
    <configuration>
        <image>mavendemo</image>
        <newName>registry.example.com/wanyang3/mavendemo:v1.0.0</newName>
    </configuration>
</execution>
...

3.6 Security Authentication Configuration

When we push images to a Docker repository, whether it is shared or private, security authentication is often required and operations can only be performed after login is completed. Of course, we can log in through the command line docker login -u user_name -p password docker_registry_host, but it is not very convenient for automated processes. Using the docker-maven-plugin plugin we can easily implement security authentication.

First, add relevant server configuration to the Maven configuration file setting.xml, mainly configuring the Docker registry user authentication information.

<servers>
  <server>
    <id>my-docker-registry</id>
    <username>wanyang3</username>
    <password>12345678</password>
    <configuration>
      <email>[email protected]</email>
    </configuration>
  </server>
</servers>

Then just use the server id in pom.xml.

<plugin>
  <plugin>
    <groupId>com.spotify</groupId>
    <artifactId>docker-maven-plugin</artifactId>
    <version>1.0.0</version>
    <configuration>
      <imageName>registry.example.com/wanyang3/mavendemo:v1.0.0</imageName>
      ...
      <serverId>my-docker-registry</serverId>
    </configuration>
  </plugin>
</plugins>

3.7 Other parameters

The docker-maven-plugin plugin also provides many useful configurations. Here are a few parameters.

4. FAQ

1. When executing build images, error 1:

[INFO] Building image mavendemo
org.apache.http.impl.execchain.RetryExec execute
I/O exception (java.io.IOException) caught when processing request to {}->unix://localhost:80: No such file or directory
[ERROR] Failed to execute goal com.spotify:docker-maven-plugin:1.0.0:build (default-cli) on project mavenDemo: Exception caught: java.util.concurrent.ExecutionException: com.spotify.docker.client.shaded.javax.ws.rs.ProcessingException: java.io.IOException: No such file or directory -> [Help 1]

This is because the Docker service is not started. Just start Docker.

2. When executing build images, error 2 is reported:

ERROR] Failed to execute goal com.spotify:docker-maven-plugin:1.0.0:build (default-cli) on project mavenDemo: Exception caught: Request error: POST unix://localhost:80/build?t=mavenDemo: 500, body: {"message":"Error parsing reference: \"mavenDemo\" is not a valid repository/tag: repository name must be lowercase"}: HTTP 500 Internal Server Error -> [Help 1]

This is because the image name is incorrect. The Docker image name must match [a-z0-9-_.].

This is the end of this article about docker-maven-plugin packaging images and uploading them to private repositories. For more information about docker-maven-plugin packaging images, 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!