Openshift and AWS Lambda Deployment With Quarkus

Nowadays Quarkus is known as Supersonic Subatomic Java. It provides a lot of features to facilitate build and deployment.

Elina Valieva

May. 08, 20 · Microservices Zone · Tutorial

Like (5)

Save

8.97K Views

Nowadays Quarkus is known as Supersonic Subatomic Java. It provides a lot of features to facilitate build and deployment. To did my best by creating a small blog application with quarkus with installed features: rest-client, security, spring-data-jpa, smallrye-health and openapi, Kubernetes, and AWS deployment to tried it real.

Prerequisites

JDK 11— for running app
Gradle 6+ — for packaging
Docker
OpenShift CLI — for deploying on OpenShift
AWS CLI, AWS SAM CLI — for deploying AWS Lambda

Docker

Quarkus provides extensions for building (and pushing) container images. Currently, it supports Jib, S2I, Docker.

To working with Docker containerization add Gradle dependency:

implementation 'io.quarkus:quarkus-container-image-docker'

Configure the docker image and remote registry in application.properties :

     Dockerfile
    
xxxxxxxxxx

quarkus.container-image.name=blog-api
quarkus.container-image.tag=latest
quarkus.container-image.registry=docker.io
quarkus.container-image.username=<USERNAME>
quarkus.container-image.password=<PASSWORD>
quarkus.container-image.push=true

Or override properties on Gradle command:

     Dockerfile
    
xxxxxxxxxx

./gradlew quarkusBuild 
           -Dquarkus.container-image.username=<USERNAME> \
           -Dquarkus.container-image.password=<PASSWORD> \
           -Dquarkus.container-image.push=true

As it’s possible to create a multistage Dockerfile to avoid packaging:

     Dockerfile
    
xxxxxxxxxx

####
# This Dockerfile.multistage is used in order to build a container that runs the Quarkus application in JVM mode
# docker build -t quarkus-quickstart:jvm -f src/main/docker/Dockerfile.multistage .
# docker run -i --rm -p 8080:8080 quarkus-quickstart:jvm
###
# Build jar with gradle
FROM gradle:jdk11 AS build_image
ENV APP_HOME=/root/dev/myapp/
USER root
RUN mkdir -p $APP_HOME/src/main/java
WORKDIR $APP_HOME
COPY build.gradle gradlew gradlew.bat $APP_HOME
COPY gradle $APP_HOME/gradle
COPY . .
RUN ./gradlew -PawsLambdaEnabled=false quarkusBuild
FROM registry.access.redhat.com/ubi8/ubi-minimal:8.1
ARG JAVA_PACKAGE=java-11-openjdk-headless
ARG RUN_JAVA_VERSION=1.3.5
ENV LANG='en_US.UTF-8' LANGUAGE='en_US:en'
# Install java and the run-java script
# Also set up permissions for user `1001`
RUN microdnf install curl ca-certificates ${JAVA_PACKAGE} \
    && microdnf update \
    && microdnf clean all \
    && mkdir /deployments \
    && chown 1001 /deployments \
    && chmod "g+rwX" /deployments \
    && chown 1001:root /deployments \
    && curl https://repo1.maven.org/maven2/io/fabric8/run-java-sh/${RUN_JAVA_VERSION}/run-java-sh-${RUN_JAVA_VERSION}-sh.sh -o /deployments/run-java.sh \
    && chown 1001 /deployments/run-java.sh \
    && chmod 540 /deployments/run-java.sh \
    && echo "securerandom.source=file:/dev/urandom" >> /etc/alternatives/jre/lib/security/java.security
# Configure the JAVA_OPTIONS, you can add -XshowSettings:vm to also display the heap size.
ENV JAVA_OPTIONS="-Dquarkus.http.host=0.0.0.0 -Djava.util.logging.manager=org.jboss.logmanager.LogManager"
COPY --from=build_image /root/dev/myapp/build/lib/* /deployments/lib/
COPY --from=build_image /root/dev/myapp/build/*-runner.jar /deployments/app.jar
EXPOSE 8090
USER 1001
ENTRYPOINT [ "/deployments/run-java.sh" ]

OpenShift Deployment

To deploy on Openshift without Quarkus possible to define template.yaml:

     YAML
    
 

      
     

       

      

       

      

      

     
xxxxxxxxxx

           

          

           

          

             
           
apiVersion: v1
kind: Template
metadata:
  name: my-template
objects:
- kind: DeploymentConfig
  apiVersion: v1
  metadata:
      labels:
        ${TAG}: ${SELECTOR_APP_NAME}
      name: ${APP_NAME}
      namespace: ${NAMESPACE_NAME}
  spec:
      replicas: 1
      revisionHistoryLimit: 10
      selector:
        app: ${APP_NAME}
        deploymentconfig: ${APP_NAME}
      strategy:
        activeDeadlineSeconds: 21600
        resources: {}
        rollingParams:
          intervalSeconds: 1
          maxSurge: 25%
          maxUnavailable: 25%
          timeoutSeconds: 600
          updatePeriodSeconds: 1
        type: Rolling
      template:
        metadata:
          annotations:
            openshift.io/generated-by: OpenShiftNewApp
          creationTimestamp: null
          labels:
            app: ${APP_NAME}
            deploymentconfig: ${APP_NAME}
        spec:
          containers:
            - env:
              name: ${APP_NAME}
              ports:
                - containerPort: 8090
                  protocol: TCP
              resources: {}
          dnsPolicy: ClusterFirst
          restartPolicy: Always
          schedulerName: default-scheduler
          securityContext: {}
          terminationGracePeriodSeconds: 30
      test: false
      triggers:
        - type: ConfigChange
        - imageChangeParams:
            automatic: true
            containerNames:
              - ${APP_NAME}
            from:
              kind: ImageStreamTag
              name: 'blog-api:latest'
              namespace: ${NAMESPACE_NAME}
          type: ImageChange
- kind: Service
  apiVersion: v1
  metadata:
    labels:
        ${TAG}: ${SELECTOR_APP_NAME}
    name: ${APP_NAME}
    namespace: ${NAMESPACE_NAME}
  spec:
    ports:
        - name: 80-tcp
          port: 80
          protocol: TCP
          targetPort: 8090
    selector:
        app: ${APP_NAME}
        deploymentconfig: ${APP_NAME}
  sessionAffinity: None
  type: ClusterIP
  status:
    loadBalancer: {}
- kind: Route
  apiVersion: v1
  metadata:
    labels:
        ${TAG}: ${SELECTOR_APP_NAME}
    name: ${APP_NAME}
    namespace: ${NAMESPACE_NAME}
  spec:
    host: ${HOST_NAME}
    port:
        targetPort: 80-tcp
    to:
        kind: Service
        name: ${APP_NAME}
        weight: 100
    wildcardPolicy: None
parameters:
- name: NAMESPACE_NAME
- name: SELECTOR_APP_NAME
- name: APP_NAME
  value: quarkus-blog-api
- name: HOST_NAME
- name: TAG
  value: app

       

      

And processed:

     Dockerfile
    
xxxxxxxxxx

oc tag elvaliev/blog-api:latest
oc process NAMESPACE_NAME=<OPENSHIFT-PROJECT> \
           SELECTOR_APP_NAME=<SELECTOR> \
           HOST_NAME=<APPLICATION_HOST> \
           -f template.yaml | oc apply -f-

By using docker containerization it’s also possible to deploy an application using image-stream from the docker registry.

     Dockerfile
    
xxxxxxxxxx

oc new-app elvaliev/blog-api:latest
oc expose svc/blog-api

But, Quarkus offers the ability to automatically generate Kubernetes resources. It currently supports generating resources for Kubernetes, OpenShift, and Knative.

Gradle dependency:

implementation 'io.quarkus:quarkus-kubernetes'

To enable the generation of necessary templates you need to include the target in application.properties:

quarkus.kubernetes.deployment-target=kubernetes,openshift

Optionally you could set up the custom configuration for your template:

     Dockerfile
    
xxxxxxxxxx

quarkus.kubernetes.annotations.app=blog
quarkus.kubernetes.labels.app=blog
# To create route for your application
quarkus.openshift.expose=true

After packaging quarkus generate target templates:

Deploy application via command:

oc create -f build/kubernetes/openshift.yml

Also, it’s possible to deploy — using S2I.

     Dockerfile
    
xxxxxxxxxx

oc new-app quay.io/quarkus/ubi-quarkus-native-s2i:19.3.1-java11~<GIT REPOSITORY> 
                                         --context-dir=. --name=quarkus-blog-api
              
oc expose svc/quarkus-blog-a

AWS Deployment

Note: use only the last version of quarkus — 1.4.1.

Dependency for Gradle:

implementation 'io.quarkus:quarkus-amazon-lambda-http'

After packaging quarkus generate sam templates for AWS:

For deploying an application as an AWS Lambda use template from the build. For native build use template build/sam.native.yaml.

I followed quarkus-documentation:

     Dockerfile
    
xxxxxxxxxx

sam local start-api --template build/sam.jvm.yaml
sam package --template-file build/sam.jvm.yaml --output-template-file packaged.yaml --s3-bucket <S3_BUCKET>
sam deploy --template-file packaged.yaml --capabilities CAPABILITY_IAM --stack-name <YOUR_STACK_NAME>

Note: To avoiding timeout error (502 — BAD GATEWAY) — increase Timeout in build/sam.jvm.yaml

Note: For using Docker containerization you need to exclude quarkus-amazon-lambda-http dependency on jar packaging (packaging with the condition properties awsLambdaEnabled=false from gradle.properties ):

     Dockerfile
    
xxxxxxxxxx

if (project.property(“awsLambdaEnabled”) != “true”) { 
   configurations { 
       runtime.exclude group: ‘io.quarkus’, 
                       module: ‘quarkus-amazon-lambda-http’ 
    }
}

Github: https://github.com/ElinaValieva/quarkus-quickstarts

Topics:

quarkus, docker, aws lambda, openshift, deployment, quarkus tutorial, gradle, java, quarkus image, openshift container

Opinions expressed by DZone contributors are their own.

Comments