GitLab: build and distribute your Java application using a Docker image

The goal of this post is to build an application with Gitlab, build the docker image, and store it in the GitLab Repository.

We will use the free version of GitLab. The example is using a Java application and maven.

This is a basic setup that you can extend and modify according to your requirements.

• .gitlab-ci.yml
  • stages
  • variables
  • cache
  • stage number one, build the application
  • stage number two, docker build and store
• Dockerfile
• Build it

.gitlab-ci.yml

To tell GitLab what it has to do with our project we have to create a .gitlab-cy.yml file in the root folder of our project.

The file will contain the steps required to build and distribute our application.

stages

In our .gitlab-ci.yml file we have to define the stages to be done, in our case we define 2 stages:

stages: 
  - build 
  - dockerize 

build will build our application from the source code and dockerize will create the docker image and store into the registry.

When the image is stored in GitLab, your server or cloud can retrieve and deploy it.

variables

In our yml we define some variables that can be used in the different stages:

variables: 
  MAVEN_OPTS: >- 
  -Dhttps.protocols=TLSv1.2 
  -Dmaven.repo.local=$CI_PROJECT_DIR/.m2/repository 
  -Dorg.slf4j.simpleLogger.showDateTime=true 
  -Djava.awt.headless=true 
 
  CONTAINER_TEST_IMAGE: $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG 
   
  MAVEN_IMAGE: maven:3.9.6-eclipse-temurin-21-jammy 
   
  IMAGE_TAG: $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG 
 
  # Tell 'docker:dind' to enable TLS (recommended) 
  # and generate certificates in the specified directory. 
  DOCKER_TLS_CERTDIR: "/certs" 
   
  MAVEN_CLI_OPTS: >- 
  --batch-mode 
  --errors 
  --fail-at-end 
  --show-version 
  --no-transfer-progress 
  -DinstallAtEnd=true 
  -DdeployAtEnd=true 

cache

We can cache the downloaded dependencies between builds.

cache: 
  paths: 
    - .m2/repository 

stage number one, build the application

maven-build: 
  stage: build 
  image: $MAVEN_IMAGE 
  script: 
    - mvn $MAVEN_CLI_OPTS clean install 
  artifacts: 
    name: "my-app" 
    paths: 
      - target/*.jar 

Now we can build our application from the source code.

stage number two, docker build and store

The last step is to retrieve the JAR built in the previous stage, read the dockerfile in our project, and build the image.

The image will be stored in your registry for the project.

dockerize: 
  stage: dockerize 
  # Specify a Docker image to run the job in. 
  image: docker:latest 
  # Specify an additional image 'docker:dind' ("Docker-in-Docker") that 
  # will start up the Docker daemon when it is brought up by a runner. 
  services: 
    - docker:dind 
  script: 
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY 
    - docker build -t $IMAGE_TAG . 
    - docker push $IMAGE_TAG 
  dependencies: 
    - maven-build 

Dockerfile

To build the docker image you need to define a Dockerfile in the root folder of your project.

Here you find a basic example of dockerfile that builds and launches a Java application.

# Example using MS Build of OpenJDK image directly 
FROM eclipse-temurin:21-jre-alpine 
 
RUN addgroup -S spring && adduser -S spring -G spring 
 
# if you use a non-root user, activate it after the mkdir 
USER spring:spring 
 
COPY target/*.jar /opt/myApp.jar 
 
# we set /opt as the working directory for the container 
WORKDIR /opt 
 
ENTRYPOINT ["java", "-jar", "myApp.jar"] 

Build it

When you update your code source, the build should start and the artifacts will be stored in the Artifacts page.

You can access remotely your Repository with your username and an access token.