How to dockerize maven project and how many ways to accomplish it

Question

I am new to Docker  and don t know how to run a java project with maven even though I have read many documents and tried many methods     Should I build the image using Dockerfile  What is the commands like when it is to run the maven project in the host with Dockerfile

User · Accepted Answer

Working example   This is not a spring boot tutorial  It s the updated answer to a question on how to run a Maven build within a Docker container   Question originally posted 4 years ago   1  Generate an application  Use the spring initializer to generate a demo app  https   start spring io     Extract the zip archive locally  2  Create a Dockerfile      Build stage   FROM maven 3 6 0-jdk-11-slim AS build COPY src  home app src COPY pom xml  home app RUN mvn -f  home app pom xml clean package      Package stage   FROM openjdk 11-jre-slim COPY --from build  home app target demo-0 0 1-SNAPSHOT jar  usr local lib demo jar EXPOSE 8080 ENTRYPOINT   java   -jar    usr local lib demo jar     Note   This example uses a multi-stage build  The first stage is used to build the code  The second stage only contains the built jar and a JRE to run it  note how jar is copied between stages     3  Build the image  docker build -t demo     4  Run the image    docker run --rm -it demo latest                                                                                                                                                                                                                                                               Spring Boot            v2 1 3 RELEASE   2019-02-22 17 18 57 835  INFO 1 ---             main  com example demo DemoApplication           Starting DemoApplication v0 0 1-SNAPSHOT on f4e67677c9a9 with PID 1   usr local bin demo jar started by root in    2019-02-22 17 18 57 837  INFO 1 ---             main  com example demo DemoApplication           No active profile set  falling back to default profiles  default 2019-02-22 17 18 58 294  INFO 1 ---             main  com example demo DemoApplication           Started DemoApplication in 0 711 seconds  JVM running for 1 035    Misc  Read the Docker hub documentation on how the Maven build can be optimized to use a local repository to cache jars     https   hub docker com   maven     Update  2019-02-07   This question is now 4 years old and in that time it s fair to say building application using Docker has undergone significant change   Option 1  Multi-stage build  This new style enables you to create more light-weight images that don t encapsulate your build tools and source code   The example here again uses the official maven base image to run first stage of the build using a desired version of Maven  The second part of the file defines how the built jar is assembled into the final output image    FROM maven 3 5-jdk-8 AS build   COPY src  usr src app src   COPY pom xml  usr src app   RUN mvn -f  usr src app pom xml clean package  FROM gcr io distroless java   COPY --from build  usr src app target helloworld-1 0 0-SNAPSHOT jar  usr app helloworld-1 0 0-SNAPSHOT jar   EXPOSE 8080   ENTRYPOINT   java   -jar    usr app helloworld-1 0 0-SNAPSHOT jar       Note    I m using Google s distroless base image  which strives to provide just enough run-time for a java app         Option 2  Jib  I haven t used this approach but seems worthy of investigation as it enables you to build images without having to create nasty things like Dockerfiles  -   https   github com GoogleContainerTools jib  The project has a Maven plugin which integrates the packaging of your code directly into your Maven workflow     Original answer  Included for completeness  but written ages ago   Try using the new official images  there s one for Maven  https   registry hub docker com   maven   The image can be used to run Maven at build time to create a compiled application or  as in the following examples  to run a Maven build within a container   Example 1 - Maven running within a container  The following command runs your Maven build inside a container   docker run -it --rm          -v    pwd    opt maven          -w  opt maven          maven 3 2-jdk-7          mvn clean install   Notes    The neat thing about this approach is that all software is installed and running within the container  Only need docker on the host machine  See Dockerfile for this version   Example 2 - Use Nexus to cache files  Run the Nexus container  docker run -d -p 8081 8081 --name nexus sonatype nexus   Create a  settings xml  file    lt settings gt     lt mirrors gt       lt mirror gt         lt id gt nexus lt  id gt         lt mirrorOf gt   lt  mirrorOf gt         lt url gt http   nexus 8081 content groups public  lt  url gt       lt  mirror gt     lt  mirrors gt   lt  settings gt    Now run Maven linking to the nexus container  so that dependencies will be cached  docker run -it --rm          -v    pwd    opt maven          -w  opt maven          --link nexus nexus          maven 3 2-jdk-7          mvn -s settings xml clean install   Notes    An advantage of running Nexus in the background is that other 3rd party repositories can be managed via the admin URL transparently to the Maven builds running in local containers

User · Answer

As a rule of thumb  you should build a fat JAR using Maven  a JAR that contains both your code and all dependencies    Then you can write a Dockerfile that matches your requirements  if you can build a fat JAR you would only need a base os  like CentOS  and the JVM    This is what I use for a Scala app  which is Java-based    FROM centos centos7    Prerequisites   RUN yum -y update RUN yum -y install wget tar    Oracle Java 7  WORKDIR  opt  RUN wget --no-cookies --no-check-certificate --header  Cookie  gpw e24 http 3A 2F 2Fwww oracle com 2F  oraclelicense accept-securebackup-cookie  http   download oracle com otn-pub java jdk 7u71-b14 server-jre-7u71-linux-x64 tar gz RUN tar xzf server-jre-7u71-linux-x64 tar gz RUN rm -rf server-jre-7u71-linux-x64 tar gz RUN alternatives --install  usr bin java java  opt jdk1 7 0 71 bin java 1    App  USER daemon    This copies to local fat jar inside the image ADD  local path to packaged app appname jar  app appname jar    What to run when the container starts ENTRYPOINT    java    -jar     app appname jar       Ports used by the app EXPOSE 5000   This creates a CentOS-based image with Java7  When started  it will execute your app jar   The best way to deploy it is via the Docker Registry  it s like a Github for Docker images   You can build an image like this     current dir must contain the Dockerfile docker build -t username projectname tagname     You can then push an image in this way   docker push username projectname   this pushes all tags   Once the image is on the Docker Registry  you can pull it from anywhere in the world and run it   See Docker User Guide for more informations   Something to keep in mind   You could also pull your repository inside an image and build the jar as part of the container execution  but it s not a good approach  as the code could change and you might end up using a different version of the app without notice   Building a fat jar removes this issue

User · Answer

Create a Dockerfile     Build stage    FROM maven 3 6 3-jdk-11-slim AS build  WORKDIR usr src app  COPY       RUN mvn clean package      Package stage    FROM openjdk 11-jre-slim  ARG JAR NAME  quot project-name quot   WORKDIR  usr src app  EXPOSE   HTTP PORT   COPY --from build  usr src app target   JAR NAME  jar   app jar  CMD   quot java quot   quot -jar quot    quot   app jar quot

User · Answer

There may be many ways   But I implemented by following two ways  Given example is of maven project   1  Using Dockerfile in maven project  Use the following file structure     Demo  -- src       -- main            -- java                -- org                    -- demo                        -- Application java                  -- test    ---- Dockerfile  ---- pom xml   And update the Dockerfile as    FROM java 8 EXPOSE 8080 ADD  target demo jar demo jar ENTRYPOINT   java   -jar   demo jar     Navigate to the project folder and type following command you will be ab le to create image and run that image     mvn clean   mvn install   docker build -f Dockerfile -t springdemo     docker run -p 8080 8080 -t springdemo   Get video at Spring Boot with Docker  2  Using Maven plugins  Add given maven plugin in pom xml   lt plugin gt       lt groupId gt com spotify lt  groupId gt       lt artifactId gt docker-maven-plugin lt  artifactId gt       lt version gt 0 4 5 lt  version gt           lt configuration gt               lt imageName gt springdocker lt  imageName gt               lt baseImage gt java lt  baseImage gt               lt entryPoint gt   java    -jar       project build finalName  jar   lt  entryPoint gt               lt resources gt                   lt resource gt                       lt targetPath gt   lt  targetPath gt                       lt directory gt   project build directory  lt  directory gt                       lt include gt   project build finalName  jar lt  include gt                   lt  resource gt               lt  resources gt           lt  configuration gt       lt  plugin gt    Navigate to the project folder and type following command you will be able to create image and run that image     mvn clean package docker build   docker images   docker run -p 8080 8080 -t  lt image name gt    In first example we are creating Dockerfile and providing base image and adding jar an so  after doing that we will run docker command to build an image with specific name and then run that image    Whereas in second example we are using maven plugin in which we providing baseImage and imageName so we don t need to create Dockerfile here   after packaging maven project we will get the docker image and we just need to run that image

User · Answer

Here is my contribution  I will not try to list all tools libraries plugins that exist to take advantage of Docker with Maven   Some answers have already done it  instead of  I will focus on applications typology and the Dockerfile way  Dockerfile is really a simple and important concept of Docker  all known public images rely on that  and I think that trying to avoid understanding and using Dockerfiles is not necessarily the better way to enter in the Docker world      Dockerizing an application depends on the application itself and the goal to reach  1  For applications that we want to go on to run them on installed standalone Java server  Tomcat  JBoss  etc       The road is harder and that is not the ideal target because that adds complexity  we have to manage maintain the server  and it is less scalable and less fast than embedded servers in terms of build deploy undeploy  But for legacy applications  that may considered as a first step  Generally  the idea here is to define a Docker image for the server and to define an image per application to deploy  The docker images for the applications produce the expected WAR EAR but these are not executed as container and the image for the server application deploys the components produced by these images as deployed applications  For huge applications  millions of line of codes  with a lot of legacy stuffs   and so hard to migrate to a full spring boot embedded solution  that is really a nice improvement  I will not detail more that approach since that is for minor use cases of Docker but I wanted to expose the overall idea of that approach because I think that  for developers facing to these complex cases  it is great to know that some doors are opened to integrate Docker      2  For applications that embed bootstrap the server themselves  Spring Boot with server embedded   Tomcat  Netty  Jetty       That is the ideal target with Docker   I specified Spring Boot because that is a really nice framework to do that and that has also  a very high level of maintainability but in theory we could use any other Java way to achieve that  Generally  the idea here is to define a Docker image per application to deploy  The docker images for the applications produce a JAR or a set of JAR classes configuration files and these start a JVM with the application  java  command  when we create and start a container from these images  For new applications or applications not too complex to migrate  that way has to be favored over standalone servers because that is the standard way and the most efficient way of using containers  I will detail that approach      Dockerizing a maven application  1  Without Spring Boot      The idea is to create a fat jar with Maven  the maven assembly plugin and the maven shade plugin help for that  that contains both the compiled classes of the application and needed maven dependencies  Then we can identify two cases          if the application is a desktop or autonomous application  that doesn t need to be deployed on a server     we could specify as CMD ENTRYPOINT in the Dockerfile the java execution of the application   java -cp    fooPath   -jar myJar    if the application is a server application  for example Tomcat  the idea is the same   to get a fat jar of the application and to run a JVM in the CMD ENTRYPOINT   But here with an important difference   we need to include some logic and specific libraries  org apache tomcat embed libraries and some others  that starts the embedded server when the main application is started  We have a comprehensive guide on the heroku website  For the first case  autonomous application   that is a straight and efficient way to use Docker  For the second case  server application   that works but that is not straight   may be error prone and is not a very extensible model because you don t place your application in the frame of a mature framework such as Spring Boot that does many of these things for you and also provides a high level of extension  But that has a advantage   you have a high level of freedom because you use directly the embedded Tomcat API        2  With Spring Boot       At last  here we go  That is both simple  efficient and very well documented  There are really several approaches to make a Maven Spring Boot application to run on Docker  Exposing all of them would be long and maybe boring  The best choice depends on your requirement  But whatever the way  the build strategy in terms of docker layers looks like the same  We want to use a multi stage build   one relying on Maven for the dependency resolution and for build and another one relying on JDK or JRE to start the application       Build stage  Maven image       pom copy to the image dependencies and plugins downloads  About that  mvn dependency resolve-plugins chained to mvn dependency resolve may do the job but not always  Why   Because these plugins and  the package execution to package the fat jar may rely on different artifacts plugins and even for a same artifact plugin  these may still pull a different version   So a safer approach while potentially slower is resolving dependencies by executing exactly the mvn command used to package the application  which will pull exactly dependencies that you are need  but by skipping the source compilation and by deleting the target folder to make the processing faster and to prevent any undesirable layer change detection for that step    source code copy to the image package the application    Run stage  JDK or JRE image       copy the jar from the previous stage   Here two examples      a  A simple way without cache for downloaded maven dependencies     Dockerfile             Maven build stage         FROM maven 3 6-jdk-11 as maven build WORKDIR  app   copy pom COPY pom xml     resolve maven dependencies RUN mvn clean package -Dmaven test skip -Dmaven main skip -Dspring-boot repackage skip  amp  amp  rm -r target    copy source COPY src   src    build the app  no dependency download here  RUN mvn clean package  -Dmaven test skip    split the built app into multiple layers to improve layer rebuild RUN mkdir -p target docker-packaging  amp  amp  cd target docker-packaging  amp  amp  jar -xf    my-app  jar          JRE run stage         FROM openjdk 11 0-jre WORKDIR  app   copy built app layer by layer ARG DOCKER PACKAGING DIR  app target docker-packaging COPY --from maven build   DOCKER PACKAGING DIR  BOOT-INF lib  app lib COPY --from maven build   DOCKER PACKAGING DIR  BOOT-INF classes  app classes COPY --from maven build   DOCKER PACKAGING DIR  META-INF  app META-INF   run the app CMD java -cp   classes lib              -Djava security egd file  dev   urandom            foo bar MySpringBootApplication   Drawback of that solution   Any changes in the pom xml means re-creates the whole layer that download and stores the maven dependencies  That is generally not acceptable for applications with many dependencies  and Spring Boot pulls many dependencies   overall if you don t use a maven repository manager during the image build                                                                                                                                                                               b  A more efficient way with cache for maven dependencies downloaded     The approach is here the same but maven dependencies downloads that are cached in the docker builder cache  The cache operation relies on buildkit  experimental api of docker   To enable buildkit  the env variable DOCKER BUILDKIT 1 has to be set  you can do that where you want    bashrc  command line  docker daemon json file         Dockerfile       syntax docker dockerfile experimental          Maven build stage         FROM maven 3 6-jdk-11 as maven build WORKDIR  app   copy pom COPY pom xml     copy source COPY src   src    build the app  no dependency download here  RUN --mount type cache target  root  m2  mvn clean package -Dmaven test skip    split the built app into multiple layers to improve layer rebuild RUN mkdir -p target docker-packaging  amp  amp  cd target docker-packaging  amp  amp  jar -xf    my-app  jar          JRE run stage         FROM openjdk 11 0-jre WORKDIR  app   copy built app layer by layer ARG DOCKER PACKAGING DIR  app target docker-packaging COPY --from maven build   DOCKER PACKAGING DIR  BOOT-INF lib  app lib COPY --from maven build   DOCKER PACKAGING DIR  BOOT-INF classes  app classes COPY --from maven build   DOCKER PACKAGING DIR  META-INF  app META-INF   run the app CMD java -cp   classes lib              -Djava security egd file  dev   urandom            foo bar MySpringBootApplication

[java] How to dockerize maven project? and how many ways to accomplish it?

Working example.

1. Generate an application

2. Create a Dockerfile

3. Build the image

4. Run the image

Misc

Update (2019-02-07)

Option 1: Multi-stage build

Option 2: Jib

Original answer (Included for completeness, but written ages ago)

Example 1 - Maven running within a container

Example 2 - Use Nexus to cache files

Examples related to java

Examples related to maven

Examples related to docker