Building docker image for multi module project pushing jars to classpath - dockerfile

Question

I am trying to create docker image for my project which is having multiple modules. The need is to build the image in such a way that the image should contain the child module jar in a given classpath. The structure of my project is
parent_project
|
|
module-1
|
pom.xml
|
module-2
|
pom.xml
|
pom.xml
So ideally when the build happens it the image should have a classpath where both modules jar are to be present. But with the below given pom.xml I am seeing the images when build are overwritten with latter build. So one image is build with first module jar and second image is formed with second module jar thus final image contains only the later jar.
part of pom.xml
<modules>
<module>xxxxxxxxx_m1</module>
<module>xxxxxxxxx_m2</module>
</modules>
<build>
<plugins>
<plugin>
<groupId>com.google.cloud.tools</groupId>
<artifactId>jib-maven-plugin</artifactId>
<version>1.8.0</version>
<configuration>
<from>
<image>xxxyyyy****_base_image</image>
</from>
<container>
<entrypoint>INHERIT</entrypoint>
<appRoot>/etc/plugin</appRoot>
<environment>
<CLASSPATH>
/etc/plugin/classpath/xxxxxxxxx_m1-SNAPSHOT.jar
/etc/plugin/classpath/xxxxxxxxx_m2-SNAPSHOT.jar
</CLASSPATH>
</environment>
</container>
<containerizingMode>packaged</containerizingMode>
</configuration>
</plugin>
</plugins>
</build>
I am building the image by providing following command :-
mvn package jib:build -Dimage=<base_image>:<tag_name>

Answer 1

Your project setup makes sense only when each of the two modules xxxxx_m1 and xxxxx_m2 is a standalone app that has its own main class and can run independently of each other, each with
java -cp <xxxxx_m1-SNAPSHOT:others...> <main class in xxxxx_m1>
java -cp <xxxxx_m2-SNAPSHOT:others...> <main class in xxxxx_m2>
That is, the setup makes sense only when you intend to create two separate and independent images for two different apps. In this case, Jib is working as intended and you are producing two different container images. It's just that by saying -Dimage (equivalent to -Djib.to.image), you are giving the same target image name for the two images, so one ends up overwriting the other in the end, which doesn't make sense. If this is really the case, you just need to define <to><image> differently in each module. (You can have <pluginManagement> in the root pom.xml to declare Jib version and common Jib <configuration>, and then define module-specific Jib <configuration> in each sub-module pom.xml. I will point you to an example at the end, so keep reading.)
But I am not sure if this is what you intended, because it sounds like you want to see both modules inside a single image. Perhaps it's that _m2 is the app with a main class and _m1 is a JAR library that _m2 depends on? (That is, pom.xml in _m2 defined _m1 as a dependency?) In this case,
root pom.xml: define <pluginManagement> to declare the Jib version
_m1 pom.xml (dependency library): set <skip>true to suppress Jib image building
_m2 pom.xml: optionally define _m2-specific configuration
Take a look at this multi-module example. It has three modules, where Jib runs in hello-service and name-service to build two images, while name-service defines the shared-library module as a dependency.
In either case, I don't see a reason to set <containerizingMode>packaged or <environment><CLASSPATH> unless your app is specifically written to read the environment variable or requires to run inside a JAR (e.g., need to read JAR manifest). The default "exploded" containerizing mode is much more efficient, so just try running Jib without these.