How to automate software delivery using Quarkus and GitLab
In this day and age, organizations need to deliver innovative solutions faster than ever to their customers to stay competitive. This is why solutions that speed up software development and delivery, such as Quarkus and GitLab, are being adopted by teams across the world.
Quarkus, also known as the Supersonic Subatomic Java, is an open source Kubernetes-native Java stack tailored for OpenJDK HotSpot and GraalVM, crafted from respected Java libraries and standards. Quarkus has been steadily growing in popularity and use because of the benefits that it delivers: cost savings, faster time to market/value, and reliability. Quarkus offers two modes: Java and native. Its Java mode builds your application using the JDK and its native mode compiles your Java code into a native executable.
GitLab, the One DevOps Platform, includes capabilities for all DevOps stages, from planning to production, all with a single model and user interface to help you ship secure code faster to any cloud and drive business results. Besides DevOps support, GitLab also offers GitOps support.
The combination of Quarkus and GitLab can empower your developers and operations teams to collaborate better, spend more time innovating to deliver business value and differentiating capabilities to end users.
In this article, we show how to automate the software delivery of a generated Quarkus application in Java mode using GitLab Auto DevOps. Below we list the steps how to accomplish this.
Prerequisite
The prerequisite for the subsequent instructions is to have a K8s cluster up and running and associated to a group in your GitLab account. For an example on how to do this, please watch this video.
Generate your Quarkus project using the generator and upload to GitLab
- From a browser window, point to the Quarkus generator site, https://code.quarkus.io, and click on the button Generate your application.
Generate a sample Quarkus application using the generator
-
On the popup window, click on the button DOWNLOAD THE ZIP, to download a sample Quarkus application in a ZIP file to your local machine. The downloaded file is named
code-with-quarkus.zip
. -
Unzip the file on your local machine in a directory of your choice. This will create a new directory called
code-with-quarkus
with all the files for the sample Quarkus application. -
From a browser window, open https://gitlab.com, and log in using your GitLab credentials.
-
Head over to the GitLab group to which you associated your K8s cluster and create a blank project named
code-with-quarkus
.
Create project code-with-quarkus
- From a Terminal window on your local machine, change directory to the newly unzipped directory
code-with-quarkus
and execute the commandrm .dockerignore
to delete the.dockerignore
file that came with the sample Quarkus application. After removing this file, execute the following commands to populate your newly create Git projectcode-with-quarkus
with the contents of this directory:
NOTE: Depending on your version of git installed on your local machine, the commands below may vary. Keep in mind that the goal of the steps below is to upload the project on your local machine to your newly created GitLab project.
git init
git remote add origin https://gitlab.com/[REPLACE WITH PATH TO YOUR GROUP]/code-with-quarkus.git
git add .
git commit -m "Initial commit"
git push --set-upstream origin master
At this point, you should have your sample Quarkus application in your GitLab project code-with-quarkus
.
Modify the generated Dockerfile.jvm file and indicate its location
Since the location of the Dockerfile is not at the root level of the project, we need to create a project variable DOCKERFILE_PATH and set it to src/main/docker/Dockerfile.jvm
to indicate to the Auto Build job where to find the Dockerfile to build the container image.
-
From your
code-with-quarkus
GitLab project window, select Settings > CI/CD from the left vertical navigation menu. -
Scroll to the Variables section on the screen and click on the Expand button on the right hand side of the section.
-
Click on the Add Variable button and enter the following values for the fields in the popup:
Key = DOCKERFILE_PATH
Value = src/main/docker/Dockerfile.jvm
Type = Variable
Environment scope = All (default)
Protect variable Flag = ensure this flag is unchecked
Mask variable Flag = ensure this flag is unchecked
The variable definition should look as follows:
Add DOCKERFILE_PATH variable to the your code-with-quarkus project
- Click on the Add variable button to complete adding this variable to your project
In order for Auto Build to work, we need to make some minor modifications to the generated Dockerfile.jvm in the sample Quarkus application.
-
From your
code-with-quarkus
GitLab project window, navigate to the directorysrc/main/docker
and click on the fileDockerfile.jvm
. Click on the Edit button to start making changes to this file. -
At the top of the file, you will see about 77 lines of comments. Replace all the lines following the comments with the following code segment:
####
FROM openjdk:11 as builder
RUN mkdir /build
ADD . /build/
WORKDIR /build
RUN ./mvnw package
FROM registry.access.redhat.com/ubi8/openjdk-11:1.11
ENV LANG='en_US.UTF-8' LANGUAGE='en_US:en'
# We make four distinct layers so if there are application changes the library layers can be re-used
COPY --from=builder --chown=185 /build/target/quarkus-app/lib/ /deployments/lib/
COPY --from=builder --chown=185 /build/target/quarkus-app/*.jar /deployments/
COPY --from=builder --chown=185 /build/target/quarkus-app/app/ /deployments/app/
COPY --from=builder --chown=185 /build/target/quarkus-app/quarkus/ /deployments/quarkus/
EXPOSE 8080
USER 185
ENV AB_JOLOKIA_OFF=""
ENV JAVA_OPTS="-Dquarkus.http.host=0.0.0.0 -Djava.util.logging.manager=org.jboss.logmanager.LogManager"
ENV JAVA_APP_JAR="/deployments/quarkus-run.jar"
The lines above add a build stage calledbuilder
to do the Java build using the openjdk:11 image and adds a build
working directory to the process. The rest of the lines are effectively the same as the original except that we have updated the paths of the COPY
commands to find the appropriate files under the build
working directory.
- Click on the Commit changes button at the bottom of the New file window to create the new file.
Update the application port number
The Auto Deploy job of Auto DevOps defaults to port 5000 for applications but the sample Quarkus application uses port 8080. So, we need to override this value in the helm chart for the Auto Deploy job. This is how you do it:
- From your
code-with-quarkus
GitLab project window, click on New File from the pop-down menu next to project root name directory as shown below:
Select New file from your code-with-quarkus project top-level directory
- On the New file window, enter
.gitlab/auto-deploy-values.yaml
for the name of the new file and paste the following two lines as the content of the file:
service:
internalPort: 8080
Your window should look as follows:
Update the application port number in the helm chart for Auto Deploy
- Click on the Commit changes button at the bottom of the New file window to create the new file.
Update the version of the JDK
The sample Quarkus application includes a unit test that is automatically run by the Auto Test job, which uses a Java version not compatible with Quarkus resulting in “java.lang.UnsupportedClassVersionError” exceptions. To solve this, we need to adjust the Java runtime version to 11 since this is the lowest version of the JRE supported by Quarkus. Let’s do this:
- From your
code-with-quarkus
GitLab project window, click on New File from the pop-down menu next to project root name directory and name the new filesystem.properties
. As its contents, paste the following line into it:
- Click on the Commit changes button at the bottom of the New file window to create the new file.
Enable Auto DevOps
Lastly, we need to enable Auto DevOps for your code-with-quarkus
GitLab project.
-
From your
code-with-quarkus
GitLab project window, select Settings > CI/CD from the left vertical navigation menu. -
Scroll to the Auto DevOps section on the screen and click on the Expand button on the right hand side of the section.
-
In the section, check the Default to Auto DevOps pipeline checkbox. Then, for Deployment strategy, select on the radio button Automatic deployment to staging, manual deployment to production. Finally, click on the Save changes button. Here’s an example screenshot:
Enable Auto DevOps for your sample Quarkus project
This will launch an Auto DevOps pipeline that will build, test and deploy your application first to the staging environment and then give you the option to manually deploy to 100% of the production environment. The completed Auto DevOps pipeline should look like this:
Completed Auto DevOps pipeline for a sample Quarkus application in Java mode
Conclusion
The combination of Quarkus and GitLab can empower your developers and operations teams to collaborate better, spend more time innovating to deliver business value and differentiating capabilities to end users.
In this article, we showed how to automate the software delivery of a generated Quarkus application in Java mode using GitLab Auto DevOps. Here is a working sample project of this Quarkus application, whose delivery has been automated by GitLab Auto DevOps.